Executing custom playbook code in a hybrid security operations application environment

ABSTRACT

Techniques are described for enabling a cloud-based IT and security operations application to execute playbooks containing custom code in a manner that mitigates types of risk related to the misuse of cloud-based resources and security of user data. Users use a client application to create and modify playbooks and, upon receiving input to save a playbook, the client application determines whether the playbook includes custom code. If the client application determines that the playbook includes custom code, the client application establishes a connection with a proxy application (also referred to as an “automation broker”) running in the user&#39;s own on-premises network and sends a representation of the playbook to the proxy application. The client application further sends to the IT and security operations application an identifier of the playbook and an indication that the playbook (or the custom code portions of the playbook) is stored within the user&#39;s on-premises network.

CROSS-REFERENCE TO RELATED APPLICATIONS

This application claims benefit under 35 U.S.C. § 120 as a continuationof U.S. application Ser. No. 16/863,896, filed Apr. 30, 2020, the entirecontents of which are hereby incorporated by reference as if fully setforth herein. The applicant(s) hereby rescind any disclaimer of claimscope in the parent application(s) or the prosecution history thereofand advise the USPTO that the claims in this application may be broaderthan any claim in the parent application(s).

FIELD

At least one embodiment of the present disclosure relates to techniquesfor securely executing custom code in a playbook created using acloud-based information technology (IT) and security operationsapplication.

BACKGROUND

Modern data centers and other computing environments can compriseanywhere from a few host computer systems to thousands of systemsconfigured to process data, service requests from remote clients, andperform numerous other computational tasks. During operation, variouscomponents within these computing environments often generatesignificant volumes of machine-generated data (“machine data”). Ingeneral, machine data can include performance data, diagnosticinformation and/or any of various other types of data indicative ofperformance or operation of equipment in a computing system. Such datacan be analyzed to diagnose equipment performance problems, monitor userinteractions, and to derive other insights.

A number of tools are available to analyze machine-generated data. Inorder to reduce the volume of the potentially vast amount of machinedata that may be generated, many of these tools typically pre-processthe data based on anticipated data-analysis needs. For example,pre-specified data items may be extracted from the machine data andstored in a database to facilitate efficient retrieval and analysis ofthose data items at search time. However, the rest of the machine datatypically is not saved and is discarded during pre-processing. Asstorage capacity becomes progressively cheaper and more plentiful, thereare fewer incentives to discard these portions of machine data and manyreasons to retain more of the data.

This plentiful storage capacity is presently making it feasible to storemassive quantities of minimally processed machine data for laterretrieval and analysis. In general, storing minimally processed machinedata and performing analysis operations at search time can providegreater flexibility because it enables an analyst to search all of themachine data, instead of searching only a pre-specified set of dataitems. This may, for example, enable an analyst to investigate differentaspects of the machine data that previously were unavailable foranalysis. However, analyzing and searching massive quantities of machinedata presents a number of challenges.

BRIEF DESCRIPTION OF DRAWINGS

Various embodiments in accordance with the present disclosure will bedescribed with reference to the drawings, in which:

FIG. 1 is a block diagram of an example networked computer environment,in accordance with example embodiments.

FIG. 2 is a block diagram of an example data intake and query system, inaccordance with example embodiments.

FIG. 3A is a block diagram of one embodiment an intake system.

FIG. 3B is a block diagram of another embodiment of an intake system.

FIG. 4A is a block diagram illustrating an embodiment of an indexingsystem of the data intake and query system.

FIG. 4B is a block diagram illustrating an embodiment of an indexingsystem of the data intake and query system.

FIG. 5 is a block diagram illustrating an embodiment of a query systemof the data intake and query system.

FIG. 6 is a block diagram illustrating an embodiment of a metadatacatalog.

FIG. 7 is a data flow diagram depicting illustrative interactions forprocessing data through an intake system, in accordance with exampleembodiments.

FIG. 8 is a data flow diagram illustrating an embodiment of the dataflow and communications between a variety of the components of the dataintake and query system during indexing.

FIG. 9 is a data flow diagram illustrating an embodiment of the dataflow and communications between a variety of the components of the dataintake and query system during execution of a query.

FIG. 10 is a data flow diagram illustrating an embodiment of the dataflow for identifying query datasets and query configuration parametersfor a particular query.

FIG. 11A is a flow diagram of an example method that illustrates howindexers process, index, and store data received from intake system, inaccordance with example embodiments.

FIG. 11B is a block diagram of a data structure in which time-stampedevent data can be stored in a data store, in accordance with exampleembodiments.

FIG. 11C provides a visual representation of the manner in which apipelined search language or query operates, in accordance with exampleembodiments.

FIG. 12A is a flow diagram of an example method that illustrates how asearch head and indexers perform a search query, in accordance withexample embodiments.

FIG. 12B provides a visual representation of an example manner in whicha pipelined command language or query operates, in accordance withexample embodiments.

FIG. 13A is a diagram of an example scenario where a common customeridentifier is found among log data received from three disparate datasources, in accordance with example embodiments.

FIG. 13B illustrates an example of processing keyword searches and fieldsearches, in accordance with disclosed embodiments.

FIG. 13C illustrates an example of creating and using an inverted index,in accordance with example embodiments.

FIG. 13D is a flow diagram of an example use of an inverted index in apipelined search query, in accordance with example embodiments.

FIG. 14 is an example search query received from a client and executedby search peers, in accordance with example embodiments.

FIG. 15 is an interface diagram of an example user interface of a keyindicators view, in accordance with example embodiments.

FIG. 16 is a block diagram of an example information technology (IT) andsecurity operations application according to some embodiments.

FIG. 17 illustrates an example interface used to manage digitalplaybooks associated with an IT and security operations applicationaccording to some embodiments.

FIG. 18 illustrates an example visual playbook editor interface used tocreate a digital playbook according to some embodiments.

FIG. 19 illustrates an example workbook template configuration interfaceused to create a workbook according to some embodiments.

FIG. 20 illustrates an example workbook template review interfacedisplaying information about a defined workbook template according tosome embodiments.

FIG. 21 illustrates an example of a “mission control” interface of an ITand security operations application displaying information regarding anoccurrence of an incident in an IT environment according to someembodiments.

FIG. 22 illustrates an example of editing source code associated with ablock of a playbook using a visual playbook editor according to someembodiments.

FIG. 23 illustrates an example of adding a custom code block to aplaybook using a visual playbook editor according to some embodiments.

FIG. 24 illustrates an example of modifying a custom code block added toa playbook using a visual playbook editor according to some embodiments.

FIG. 25 illustrates an example of referencing a custom code block outputvariable at another block of the playbook using a visual playbook editoraccording to some embodiments.

FIG. 26 is a flow diagram illustrating operations of a method forproviding a visual playbook editor used to create playbooks for an ITand security operations application, the visual playbook editorincluding the ability to add custom code function blocks to a playbook,according to some embodiments.

FIG. 27 is a diagram illustrating a networked computing environment inwhich an IT and security operations application enables the secureexecution of custom playbook code in a hybrid execution environmentaccording to some embodiments.

FIG. 28 is a flow diagram illustrating operations of a method forenabling the secure execution of custom playbook code in a hybridexecution environment according to some embodiments.

FIG. 29 is a block diagram illustrating an example computer system thatmay be used in some embodiments.

DETAILED DESCRIPTION

Embodiments are described herein according to the following outline:

1.0. General Overview

2.0. Operating Environment

-   -   2.1. Host Devices    -   2.2. Client Devices    -   2.3. Client Device Applications    -   2.4. Data Intake and Query System Overview    -   2.5. On-Premise and Shared Computing Resource Environments

3.0. Data Intake and Query System Architecture

-   -   3.1 Gateway    -   3.2. Intake System        -   3.2.1. Forwarder        -   3.2.2. Data Retrieval Subsystem        -   3.2.3. Ingestion Buffer        -   3.2.4. Streaming Data Processors    -   3.3. Indexing System        -   3.3.1. Indexing System Manager        -   3.3.2. Ingest Manager        -   3.3.3. Partition Manager        -   3.3.4. Indexing Nodes            -   3.3.4.1. Indexer and Data Store            -   3.3.4.2. Bucket Manager        -   3.3.5. Resource Catalog        -   3.3.6. Resource Monitor    -   3.4. Query System        -   3.4.1. Query System Manager        -   3.4.2. Search Head            -   3.4.2.1. Search Master            -   3.4.2.2. Search Manager                -   3.4.2.2.1. Search Head-node Mapping Policy                -   3.4.2.2.2. Search Node-Data Mapping Policy        -   3.4.3. Search Nodes        -   3.4.4. Cache Manager        -   3.4.5. Resource Monitor and Catalog    -   3.5. Common Storage    -   3.6. Data Store Catalog    -   3.7. Query Acceleration Data Store    -   3.8. Metadata Catalog        -   3.8.1. Dataset Association Records        -   3.8.2. Dataset Configuration Records        -   3.8.3. Rule Configuration Records        -   3.8.4. Annotations            -   3.8.4.1. Generating Annotations                -   3.8.4.1.1. System Annotations Based on System Use                -    3.8.4.1.1.1. Query Parsing                -    3.8.4.1.1.2. Query Execution                -    3.8.4.1.1.3. User Monitoring                -    3.8.4.1.1.4. Application Monitoring                -   3.8.4.1.2. System Annotations Based on Metadata                    Catalog            -   Changes            -   3.8.4.2. Example Annotations                -   3.8.4.2.1. Field Annotations                -   3.8.4.2.2. Inter-Field Relationship Annotations                -   3.8.4.2.3. Inter-Dataset Relationship Annotations                -   3.8.4.2.4. Dataset properties Annotations                -   3.8.4.2.5. Normalization Annotations                -   3.8.4.2.6. Unit Annotations                -   3.8.4.2.7. Alarm Threshold Annotations                -   3.8.4.2.8. Data Category Annotations                -   3.8.4.2.9. User/Group Annotations                -   3.8.4.2.10. Application Annotations

4.0. Data Intake and Query System Functions

-   -   4.1. Intake        -   4.1.1. Publication to Intake Topic(s)        -   4.1.2. Transmission to Streaming Data Processors        -   4.1.3. Messages Processing        -   4.1.4. Transmission to Subscribers        -   4.1.5. Data Resiliency and Security    -   4.2. Indexing    -   4.3. Querying        -   4.3.1. Example Metadata Catalog Processing    -   4.4. Data Ingestion, Indexing, and Storage Flow        -   4.4.1. Input        -   4.4.2. Parsing        -   4.4.3. Indexing    -   4.5. Query Processing Flow    -   4.6. Pipelined Search Language    -   4.7. Field Extraction    -   4.8. Data Models    -   4.9. Acceleration Techniques        -   4.9.1. Aggregation Technique        -   4.9.2. Keyword Index        -   4.9.3. High Performance Analytics Store            -   4.9.3.1. Extracting Event Data Using Posting        -   4.9.4. Accelerating Report Generation    -   4.10. Security Features    -   4.11. Data Center Monitoring    -   4.12. IT Service Monitoring    -   4.13. Other Architectures

5.0. IT and Security Operations Application Overview

-   -   5.1. Data Intake    -   5.2. Actions    -   5.3. Connectors    -   5.4. Assets    -   5.5. Playbooks        -   5.5.1. Playbooks Management        -   5.5.2. Playbook Creation and Configuration        -   5.5.3. Playbook Execution    -   5.6. Workbooks

6.0. Automatically Configuring IT and Security Operations ApplicationConnectors

7.0. Terminology

1.0. General Overview

Modern data centers and other computing environments can compriseanywhere from a few host computer systems to thousands of systemsconfigured to process data, service requests from remote clients, andperform numerous other computational tasks. During operation, variouscomponents within these computing environments often generatesignificant volumes of machine data. Machine data is any data producedby a machine or component in an information technology (IT) environmentand that reflects activity in the IT environment. For example, machinedata can be raw machine data that is generated by various components inIT environments, such as servers, sensors, routers, mobile devices,Internet of Things (IoT) devices, etc. Machine data can include systemlogs, network packet data, sensor data, application program data, errorlogs, stack traces, system performance data, etc. In general, machinedata can also include performance data, diagnostic information, and manyother types of data that can be analyzed to diagnose performanceproblems, monitor user interactions, and to derive other insights.

A number of tools are available to analyze machine data. In order toreduce the size of the potentially vast amount of machine data that maybe generated, many of these tools typically pre-process the data basedon anticipated data-analysis needs. For example, pre-specified dataitems may be extracted from the machine data and stored in a database tofacilitate efficient retrieval and analysis of those data items atsearch time. However, the rest of the machine data typically is notsaved and is discarded during pre-processing. As storage capacitybecomes progressively cheaper and more plentiful, there are fewerincentives to discard these portions of machine data and many reasons toretain more of the data.

This plentiful storage capacity is presently making it feasible to storemassive quantities of minimally processed machine data for laterretrieval and analysis. In general, storing minimally processed machinedata and performing analysis operations at search time can providegreater flexibility because it enables an analyst to search all of themachine data, instead of searching only a pre-specified set of dataitems. This may enable an analyst to investigate different aspects ofthe machine data that previously were unavailable for analysis.

However, analyzing and searching massive quantities of machine datapresents a number of challenges. For example, a data center, servers, ornetwork appliances may generate many different types and formats ofmachine data (e.g., system logs, network packet data (e.g., wire data,etc.), sensor data, application program data, error logs, stack traces,system performance data, operating system data, virtualization data,etc.) from thousands of different components, which can collectively bevery time-consuming to analyze. In another example, mobile devices maygenerate large amounts of information relating to data accesses,application performance, operating system performance, networkperformance, etc. There can be millions of mobile devices that reportthese types of information.

These challenges can be addressed by using an event-based data intakeand query system, such as the SPLUNK® ENTERPRISE system developed bySplunk Inc. of San Francisco, Calif. The SPLUNK® ENTERPRISE system isthe leading platform for providing real-time operational intelligencethat enables organizations to collect, index, and search machine datafrom various websites, applications, servers, networks, and mobiledevices that power their businesses. The data intake and query system isparticularly useful for analyzing data which is commonly found in systemlog files, network data, and other data input sources. Although many ofthe techniques described herein are explained with reference to a dataintake and query system similar to the SPLUNK® ENTERPRISE system, thesetechniques are also applicable to other types of data systems.

In the data intake and query system, machine data are collected andstored as “events”. An event comprises a portion of machine data and isassociated with a specific point in time. The portion of machine datamay reflect activity in an IT environment and may be produced by acomponent of that IT environment, where the events may be searched toprovide insight into the IT environment, thereby improving theperformance of components in the IT environment. Events may be derivedfrom “time series data,” where the time series data comprises a sequenceof data points (e.g., performance measurements from a computer system,etc.) that are associated with successive points in time. In general,each event has a portion of machine data that is associated with a timestamp that is derived from the portion of machine data in the event. Atimestamp of an event may be determined through interpolation betweentemporally proximate events having known timestamps or may be determinedbased on other configurable rules for associating timestamps withevents.

In some instances, machine data can have a predefined format, where dataitems with specific data formats are stored at predefined locations inthe data. For example, the machine data may include data associated withfields in a database table. In other instances, machine data may nothave a predefined format (e.g., may not be at fixed, predefinedlocations), but may have repeatable (e.g., non-random) patterns. Thismeans that some machine data can comprise various data items ofdifferent data types that may be stored at different locations withinthe data. For example, when the data source is an operating system log,an event can include one or more lines from the operating system logcontaining machine data that includes different types of performance anddiagnostic information associated with a specific point in time (e.g., atimestamp).

Examples of components which may generate machine data from which eventscan be derived include, but are not limited to, web servers, applicationservers, databases, firewalls, routers, operating systems, and softwareapplications that execute on computer systems, mobile devices, sensors,Internet of Things (IoT) devices, etc. The machine data generated bysuch data sources can include, for example and without limitation,server log files, activity log files, configuration files, messages,network packet data, performance measurements, sensor measurements, etc.

The data intake and query system uses a flexible schema to specify howto extract information from events. A flexible schema may be developedand redefined as needed. Note that a flexible schema may be applied toevents “on the fly,” when it is needed (e.g., at search time, indextime, ingestion time, etc.). When the schema is not applied to eventsuntil search time, the schema may be referred to as a “late-bindingschema.”

During operation, the data intake and query system receives machine datafrom any type and number of sources (e.g., one or more system logs,streams of network packet data, sensor data, application program data,error logs, stack traces, system performance data, etc.). The systemparses the machine data to produce events each having a portion ofmachine data associated with a timestamp. The system stores the eventsin a data store. The system enables users to run queries against thestored events to, for example, retrieve events that meet criteriaspecified in a query, such as criteria indicating certain keywords orhaving specific values in defined fields. As used herein, the term“field” refers to a location in the machine data of an event containingone or more values for a specific data item. A field may be referencedby a field name associated with the field. As will be described in moredetail herein, a field is defined by an extraction rule (e.g., a regularexpression) that derives one or more values or a sub-portion of textfrom the portion of machine data in each event to produce a value forthe field for that event. The set of values produced are semanticallyrelated (such as IP address), even though the machine data in each eventmay be in different formats (e.g., semantically-related values may be indifferent positions in the events derived from different sources).

As described above, the system stores the events in a data store. Theevents stored in the data store are field-searchable, wherefield-searchable herein refers to the ability to search the machine data(e.g., the raw machine data) of an event based on a field specified insearch criteria. For example, a search having criteria that specifies afield name “UserID” may cause the system to field-search the machinedata of events to identify events that have the field name “UserID.” Inanother example, a search having criteria that specifies a field name“UserID” with a corresponding field value “12345” may cause the systemto field-search the machine data of events to identify events havingthat field-value pair (e.g., field name “UserID” with a correspondingfield value of “12345”). Events are field-searchable using one or moreconfiguration files associated with the events. Each configuration fileincludes one or more field names, where each field name is associatedwith a corresponding extraction rule and a set of events to which thatextraction rule applies. The set of events to which an extraction ruleapplies may be identified by metadata associated with the set of events.For example, an extraction rule may apply to a set of events that areeach associated with a particular host, source, or source type. Whenevents are to be searched based on a particular field name specified ina search, the system uses one or more configuration files to determinewhether there is an extraction rule for that particular field name thatapplies to each event that falls within the criteria of the search. Ifso, the event is considered as part of the search results (andadditional processing may be performed on that event based on criteriaspecified in the search). If not, the next event is similarly analyzed,and so on.

As noted above, the data intake and query system utilizes a late-bindingschema while performing queries on events. One aspect of a late-bindingschema is applying extraction rules to events to extract values forspecific fields during search time. More specifically, the extractionrule for a field can include one or more instructions that specify howto extract a value for the field from an event. An extraction rule cangenerally include any type of instruction for extracting values fromevents. In some cases, an extraction rule comprises a regularexpression, where a sequence of characters form a search pattern. Anextraction rule comprising a regular expression is referred to herein asa regex rule. The system applies a regex rule to an event to extractvalues for a field associated with the regex rule, where the values areextracted by searching the event for the sequence of characters definedin the regex rule.

In the data intake and query system, a field extractor may be configuredto automatically generate extraction rules for certain fields in theevents when the events are being created, indexed, or stored, orpossibly at a later time. Alternatively, a user may manually defineextraction rules for fields using a variety of techniques. In contrastto a conventional schema for a database system, a late-binding schema isnot defined at data ingestion time. Instead, the late-binding schema canbe developed on an ongoing basis until the time a query is actuallyexecuted. This means that extraction rules for the fields specified in aquery may be provided in the query itself or may be located duringexecution of the query. Hence, as a user learns more about the data inthe events, the user can continue to refine the late-binding schema byadding new fields, deleting fields, or modifying the field extractionrules for use the next time the schema is used by the system. Becausethe data intake and query system maintains the underlying machine dataand uses a late-binding schema for searching the machine data, itenables a user to continue investigating and learn valuable insightsabout the machine data.

In some embodiments, a common field name may be used to reference two ormore fields containing equivalent and/or similar data items, even thoughthe fields may be associated with different types of events thatpossibly have different data formats and different extraction rules. Byenabling a common field name to be used to identify equivalent and/orsimilar fields from different types of events generated by disparatedata sources, the system facilitates use of a “common information model”(CIM) across the disparate data sources.

In some embodiments, the configuration files and/or extraction rulesdescribed above can be stored in a catalog, such as a metadata catalog.In certain embodiments, the content of the extraction rules can bestored as rules or actions in the metadata catalog. For example, theidentification of the data to which the extraction rule applies can bereferred to a rule and the processing of the data can be referred to asan action.

2.0. Operating Environment

FIG. 1 is a block diagram of an example networked computer environment100, in accordance with example embodiments. It will be understood thatFIG. 1 represents one example of a networked computer system and otherembodiments may use different arrangements.

The networked computer environment 100 comprises one or more computingdevices. These one or more computing devices comprise any combination ofhardware and software configured to implement the various logicalcomponents described herein. For example, the one or more computingdevices may include one or more memories that store instructions forimplementing the various components described herein, one or morehardware processors configured to execute the instructions stored in theone or more memories, and various data repositories in the one or morememories for storing data structures utilized and manipulated by thevarious components.

In some embodiments, one or more client devices 102 are coupled to oneor more host devices 106 and a data intake and query system 108 via oneor more networks 104. Networks 104 broadly represent one or more LANs,WANs, cellular networks (e.g., LTE, HSPA, 3G, and other cellulartechnologies), and/or networks using any of wired, wireless, terrestrialmicrowave, or satellite links, and may include the public Internet.

2.1. Host Devices

In the illustrated embodiment, the environment 100 includes one or morehost devices 106. Host devices 106 may broadly include any number ofcomputers, virtual machine instances, and/or data centers that areconfigured to host or execute one or more instances of host applications114. In general, a host device 106 may be involved, directly orindirectly, in processing requests received from client devices 102.Each host device 106 may comprise, for example, one or more of a networkdevice, a web server, an application server, a database server, etc. Acollection of host devices 106 may be configured to implement anetwork-based service. For example, a provider of a network-basedservice may configure one or more host devices 106 and host applications114 (e.g., one or more web servers, application servers, databaseservers, etc.) to collectively implement the network-based application.

In general, client devices 102 communicate with one or more hostapplications 114 to exchange information. The communication between aclient device 102 and a host application 114 may, for example, be basedon the Hypertext Transfer Protocol (HTTP) or any other network protocol.Content delivered from the host application 114 to a client device 102may include, for example, HTML documents, media content, etc. Thecommunication between a client device 102 and host application 114 mayinclude sending various requests and receiving data packets. Forexample, in general, a client device 102 or application running on aclient device may initiate communication with a host application 114 bymaking a request for a specific resource (e.g., based on an HTTPrequest), and the application server may respond with the requestedcontent stored in one or more response packets.

In the illustrated embodiment, one or more of host applications 114 maygenerate various types of performance data during operation, includingevent logs, network data, sensor data, and other types of machine data.For example, a host application 114 comprising a web server may generateone or more web server logs in which details of interactions between theweb server and any number of client devices 102 is recorded. As anotherexample, a host device 106 comprising a router may generate one or morerouter logs that record information related to network traffic managedby the router. As yet another example, a host application 114 comprisinga database server may generate one or more logs that record informationrelated to requests sent from other host applications 114 (e.g., webservers or application servers) for data managed by the database server.

2.2. Client Devices

Client devices 102 of FIG. 1 represent any computing device capable ofinteracting with one or more host devices 106 via a network 104.Examples of client devices 102 may include, without limitation, smartphones, tablet computers, handheld computers, wearable devices, laptopcomputers, desktop computers, servers, portable media players, gamingdevices, and so forth. In general, a client device 102 can provideaccess to different content, for instance, content provided by one ormore host devices 106, etc. Each client device 102 may comprise one ormore client applications 110, described in more detail in a separatesection hereinafter.

2.3. Client Device Applications

In some embodiments, each client device 102 may host or execute one ormore client applications 110 that are capable of interacting with one ormore host devices 106 via one or more networks 104. For instance, aclient application 110 may be or comprise a web browser that a user mayuse to navigate to one or more websites or other resources provided byone or more host devices 106. As another example, a client application110 may comprise a mobile application or “app.” For example, an operatorof a network-based service hosted by one or more host devices 106 maymake available one or more mobile apps that enable users of clientdevices 102 to access various resources of the network-based service. Asyet another example, client applications 110 may include backgroundprocesses that perform various operations without direct interactionfrom a user. A client application 110 may include a “plug-in” or“extension” to another application, such as a web browser plug-in orextension.

In some embodiments, a client application 110 may include a monitoringcomponent 112. At a high level, the monitoring component 112 comprises asoftware component or other logic that facilitates generatingperformance data related to a client device's operating state, includingmonitoring network traffic sent and received from the client device andcollecting other device and/or application-specific information.Monitoring component 112 may be an integrated component of a clientapplication 110, a plug-in, an extension, or any other type of add-oncomponent. Monitoring component 112 may also be a stand-alone process.

In some embodiments, a monitoring component 112 may be created when aclient application 110 is developed, for example, by an applicationdeveloper using a software development kit (SDK). The SDK may includecustom monitoring code that can be incorporated into the codeimplementing a client application 110. When the code is converted to anexecutable application, the custom code implementing the monitoringfunctionality can become part of the application itself.

In some embodiments, an SDK or other code for implementing themonitoring functionality may be offered by a provider of a data intakeand query system, such as a system 108. In such cases, the provider ofthe system 108 can implement the custom code so that performance datagenerated by the monitoring functionality is sent to the system 108 tofacilitate analysis of the performance data by a developer of the clientapplication or other users.

In some embodiments, the custom monitoring code may be incorporated intothe code of a client application 110 in a number of different ways, suchas the insertion of one or more lines in the client application codethat call or otherwise invoke the monitoring component 112. As such, adeveloper of a client application 110 can add one or more lines of codeinto the client application 110 to trigger the monitoring component 112at desired points during execution of the application. Code thattriggers the monitoring component may be referred to as a monitortrigger. For instance, a monitor trigger may be included at or near thebeginning of the executable code of the client application 110 such thatthe monitoring component 112 is initiated or triggered as theapplication is launched, or included at other points in the code thatcorrespond to various actions of the client application, such as sendinga network request or displaying a particular interface.

In some embodiments, the monitoring component 112 may monitor one ormore aspects of network traffic sent and/or received by a clientapplication 110. For example, the monitoring component 112 may beconfigured to monitor data packets transmitted to and/or from one ormore host applications 114. Incoming and/or outgoing data packets can beread or examined to identify network data contained within the packets,for example, and other aspects of data packets can be analyzed todetermine a number of network performance statistics. Monitoring networktraffic may enable information to be gathered particular to the networkperformance associated with a client application 110 or set ofapplications.

In some embodiments, network performance data refers to any type of datathat indicates information about the network and/or network performance.Network performance data may include, for instance, a URL requested, aconnection type (e.g., HTTP, HTTPS, etc.), a connection start time, aconnection end time, an HTTP status code, request length, responselength, request headers, response headers, connection status (e.g.,completion, response time(s), failure, etc.), and the like. Uponobtaining network performance data indicating performance of thenetwork, the network performance data can be transmitted to a dataintake and query system 108 for analysis.

Upon developing a client application 110 that incorporates a monitoringcomponent 112, the client application 110 can be distributed to clientdevices 102. Applications generally can be distributed to client devices102 in any manner, or they can be pre-loaded. In some cases, theapplication may be distributed to a client device 102 via an applicationmarketplace or other application distribution system. For instance, anapplication marketplace or other application distribution system mightdistribute the application to a client device based on a request fromthe client device to download the application.

Examples of functionality that enables monitoring performance of aclient device are described in U.S. patent application Ser. No.14/524,748, entitled “UTILIZING PACKET HEADERS TO MONITOR NETWORKTRAFFIC IN ASSOCIATION WITH A CLIENT DEVICE”, filed on 27 Oct. 2014, andwhich is hereby incorporated by reference in its entirety for allpurposes.

In some embodiments, the monitoring component 112 may also monitor andcollect performance data related to one or more aspects of theoperational state of a client application 110 and/or client device 102.For example, a monitoring component 112 may be configured to collectdevice performance information by monitoring one or more client deviceoperations, or by making calls to an operating system and/or one or moreother applications executing on a client device 102 for performanceinformation. Device performance information may include, for instance, acurrent wireless signal strength of the device, a current connectiontype and network carrier, current memory performance information, ageographic location of the device, a device orientation, and any otherinformation related to the operational state of the client device.

In some embodiments, the monitoring component 112 may also monitor andcollect other device profile information including, for example, a typeof client device, a manufacturer, and model of the device, versions ofvarious software applications installed on the device, and so forth.

In general, a monitoring component 112 may be configured to generateperformance data in response to a monitor trigger in the code of aclient application 110 or other triggering application event, asdescribed above, and to store the performance data in one or more datarecords. Each data record, for example, may include a collection offield-value pairs, each field-value pair storing a particular item ofperformance data in association with a field for the item. For example,a data record generated by a monitoring component 112 may include a“networkLatency” field (not shown in the Figure) in which a value isstored. This field indicates a network latency measurement associatedwith one or more network requests. The data record may include a “state”field to store a value indicating a state of a network connection, andso forth for any number of aspects of collected performance data.

2.4. Data Intake and Query System Overview

In some environments, the data intake and query system 108 illustratedin FIG. 1 may be a system that includes one or more system componentssuch as forwarders, indexers, and search heads. Some examples of such asystem are described in U.S. Pat. No. 10,169,434, entitled “TOKENIZEDHTTP EVENT COLLECTOR,” the entirety of which is hereby incorporated byreference. Some exemplary data intake and query systems 108 may includeone or more forwarders that receive data from a variety of input datasources, and one or more indexers that that process and store the datain one or more data stores. These forwarders and indexers can compriseseparate computer systems, or may alternatively comprise separateprocesses executing on one or more computer systems.

In some such environments of the data intake and query system, duringoperation, the forwarders may identify which indexers receive datacollected from a data source and forward the data to the appropriateindexers. Forwarders can also perform operations on the data beforeforwarding, including removing extraneous data, detecting timestamps inthe data, parsing data, indexing data, routing data based on criteriarelating to the data being routed, and/or performing other datatransformations.

In some implementations, a forwarder may comprise a service accessibleto client devices and host devices via a network. For example, one typeof forwarder may be capable of consuming vast amounts of real-time datafrom a potentially large number of client devices and/or host devices.The forwarder may, for example, comprise a computing device whichimplements multiple data pipelines or “queues” to handle forwarding ofnetwork data to indexers. A forwarder may also perform many of thefunctions that are performed by an indexer. For example, a forwarder mayperform keyword extractions on raw data or parse raw data to createevents. A forwarder may generate time stamps for events. Additionally,or alternatively, a forwarder may perform routing of events to indexers.In some implementations, a data store may be part of the data intake andquery system, and may contain events derived from machine data from avariety of sources all pertaining to the same component in an ITenvironment, and this data may be produced by the machine in question orby other components in the IT environment.

The data intake and query system 108 can process and store data receiveddata from the data sources client devices 102 or host devices 106 andexecute queries on the data in response to requests received from one ormore computing devices. In some cases, the data intake and query system108 can generate events from the received data and store the events inbuckets in a common storage system. In response to received queries, thedata intake and query system can assign one or more search nodes tosearch the buckets in the common storage.

In certain embodiments, the data intake and query system 108 can includevarious components that enable it to provide stateless services orenable it to recover from an unavailable or unresponsive componentwithout data loss in a time efficient manner. For example, the dataintake and query system 108 can store contextual information about itsvarious components in a distributed way such that if one of thecomponents becomes unresponsive or unavailable, the data intake andquery system 108 can replace the unavailable component with a differentcomponent and provide the replacement component with the contextualinformation. In this way, the data intake and query system 108 canquickly recover from an unresponsive or unavailable component whilereducing or eliminating the loss of data that was being processed by theunavailable component.

In some embodiments, the data intake and query system 108 can store thecontextual information in a metadata catalog, as described herein. Incertain embodiments, the contextual information can correspond toinformation that the data intake and query system 108 has determined orlearned based on use. In some cases, the contextual information can bestored as annotations (manual annotations and/or system annotations), asdescribed herein.

2.5. On-Premise and Shared Computing Resource Environments

In some environments, a user of a data intake and query system 108 mayinstall and configure, on computing devices owned and operated by theuser, one or more software applications that implement some or all ofthe components of the data intake and query system 108. For example,with reference to FIG. 2, a user may install a software application onserver computers owned by the user and configure each server to operateas one or more components of the intake system 210, indexing system 212,query system 214, common storage 216, data store catalog 220, or queryacceleration data store 222, etc. This arrangement generally may bereferred to as an “on-premises” solution. That is, the system 108 isinstalled and operates on computing devices directly controlled by theuser of the system. Some users may prefer an on-premises solutionbecause it may provide a greater level of control over the configurationof certain aspects of the system (e.g., security, privacy, standards,controls, etc.). However, other users may instead prefer an arrangementin which the user is not directly responsible for providing and managingthe computing devices upon which various components of system 108operate.

In certain embodiments, one or more of the components of the data intakeand query system 108 can be implemented in a remote distributedcomputing system. In this context, a remote distributed computing systemor cloud-based service can refer to a service hosted by one morecomputing resources that are accessible to end users over a network, forexample, by using a web browser or other application on a client deviceto interface with the remote computing resources. For example, a serviceprovider may provide a data intake and query system 108 by managingcomputing resources configured to implement various aspects of thesystem (e.g., intake system 210, indexing system 212, query system 214,common storage 216, data store catalog 220, or query acceleration datastore 222, etc.) and by providing access to the system to end users viaa network. Typically, a user may pay a subscription or other fee to usesuch a service. Each subscribing user of the cloud-based service may beprovided with an account that enables the user to configure a customizedcloud-based system based on the user's preferences.

When implemented in a remote distributed computing system, theunderlying hardware (non-limiting examples: processors, hard drives,solid-state memory, RAM, etc.) on which the components of the dataintake and query system 108 execute can be shared by multiple customersor tenants as part of a shared computing resource environment. Inaddition, when implemented in a shared computing resource environment asa cloud-based service, various components of the system 108 can beimplemented using containerization or operating-system-levelvirtualization, or other virtualization technique. For example, one ormore components of the intake system 210, indexing system 212, or querysystem 214 can be implemented as separate software containers orcontainer instances. Each container instance can have certain resources(e.g., memory, processor, etc.) of an underlying host computing system(e.g., server, microprocessor, etc.) assigned to it, but may share thesame operating system and may use the operating system's system callinterface. Each container may provide an isolated execution environmenton the host system, such as by providing a memory space of the hostsystem that is logically isolated from memory space of other containers.Further, each container may run the same or different computerapplications concurrently or separately and may interact with eachother. Although reference is made herein to containerization andcontainer instances, it will be understood that other virtualizationtechniques can be used. For example, the components can be implementedusing virtual machines using full virtualization or paravirtualization,etc. Thus, where reference is made to “containerized” components, itshould be understood that such components may additionally oralternatively be implemented in other isolated execution environments,such as a virtual machine environment.

Implementing the data intake and query system 108 in a remotedistributed system, shared computing resource environment, or as acloud-based service can provide a number of benefits. In some cases,implementing the data intake and query system 108 in a remotedistributed system, shared computing resource environment, or as acloud-based service can make it easier to install, maintain, and updatethe components of the data intake and query system 108. For example,rather than accessing designated hardware at a particular location toinstall or provide a component of the data intake and query system 108,a component can be remotely instantiated or updated as desired.Similarly, implementing the data intake and query system 108 in a remotedistributed system, shared computing resource environment, or as acloud-based service can make it easier to meet dynamic demand. Forexample, if the data intake and query system 108 experiences significantload at indexing or search, additional compute resources can be deployedto process the additional data or queries. In an “on-premises”environment, this type of flexibility and scalability may not bepossible or feasible.

In addition, by implementing the data intake and query system 108 in aremote distributed system, shared computing resource environment, or asa cloud-based service can improve compute resource utilization. Forexample, in an on-premises environment if the designated computeresources are not being used by, they may sit idle and unused. In ashared computing resource environment, if the compute resources for aparticular component are not being used, they can be re-allocated toother tasks within the data intake and query system 108 and/or to othersystems unrelated to the data intake and query system 108.

As mentioned, in an on-premises environment, data from one instance of adata intake and query system 108 is logically and physically separatedfrom the data of another instance of a data intake and query system byvirtue of each instance having its own designated hardware. As such,data from different customers of the data intake and query system islogically and physically separated from each other.

In a shared computing resource environment, one instance of a dataintake and query system can be configured to process the data from onecustomer or tenant or from multiple customers or tenants. Even in caseswhere a separate instance of a data intake and query system is used foreach customer, the underlying hardware on which the instances of thedata intake and query system 108 are instantiated may still process datafrom different tenants. Accordingly, in a shared computing resourceenvironment, the data from different tenants may not be physicallyseparated on distinct hardware devices. For example, data from onetenant may reside on the same hard drive as data from another tenant orbe processed by the same processor. In such cases, the data intake andquery system 108 can maintain logical separation between tenant data.For example, the data intake and query system can include separatedirectories for different tenants and apply different permissions andaccess controls to access the different directories or to process thedata, etc.

In certain cases, the tenant data from different tenants is mutuallyexclusive and/or independent from each other. For example, in certaincases, Tenant A and Tenant B do not share the same data, similar to theway in which data from a local hard drive of Customer A is mutuallyexclusive and independent of the data (and not considered part) of alocal hard drive of Customer B. While Tenant A and Tenant B may havematching or identical data, each tenant would have a separate copy ofthe data. For example, with reference again to the local hard drive ofCustomer A and Customer B example, each hard drive could include thesame file. However, each instance of the file would be considered partof the separate hard drive and would be independent of the other file.Thus, one copy of the file would be part of Customer's A hard drive anda separate copy of the file would be part of Customer B's hard drive. Ina similar manner, to the extent Tenant A has a file that is identical toa file of Tenant B, each tenant would have a distinct and independentcopy of the file stored in different locations on a data store or ondifferent data stores.

Further, in certain cases, the data intake and query system 108 canmaintain the mutual exclusivity and/or independence between tenant dataeven as the tenant data is being processed, stored, and searched by thesame underlying hardware. In certain cases, to maintain the mutualexclusivity and/or independence between the data of different tenants,the data intake and query system can use tenant identifiers to uniquelyidentify data associated with different tenants.

In a shared computing resource environment, some components of the dataintake and query system can be instantiated and designated forindividual tenants and other components can be shared by multipletenants. In certain embodiments, a separate intake system 210, indexingsystem 212, and query system 214 can be instantiated for each tenant,whereas the common storage 216, data store catalog 220, metadata catalog221, and/or acceleration data store 222, can be shared by multipletenants. In some such embodiments, the common storage 216, data storecatalog 220, metadata catalog 221, and/or acceleration data store 222,can maintain separate directories for the different tenants to ensuretheir mutual exclusivity and/or independence from each other. Similarly,in some such embodiments, the data intake and query system 108 can usedifferent host computing systems or different isolated executionenvironments to process the data from the different tenants as part ofthe intake system 210, indexing system 212, and/or query system 214.

In some embodiments, individual components of the intake system 210,indexing system 212, and/or query system 214 may be instantiated foreach tenant or shared by multiple tenants. For example, individualforwarders 302 and an output ingestion buffer 310 may be instantiatedand designated for individual tenants, while the data retrievalsubsystem 304, intake ingestion buffer 306, and/or streaming dataprocessor 308, may be shared by multiple tenants. In certainembodiments, the data retrieval subsystem 304, intake ingestion buffer306, streaming data processor 308, and output ingestion buffer 310 maybe shared by multiple tenants.

In certain embodiments, an indexing system can be instantiated anddesignated for a particular tenant or shared by multiple tenants. As anon-limiting example, in certain cases, the embodiment of the indexingsystem 212 shown in FIG. 4A may be allocated for each tenant of the dataintake and query system 108. As another non-limiting example, in somecases, the components of the embodiment of the indexing system 212 shownin FIG. 4B can be shared by multiple tenants.

In some embodiments where a separate indexing system 212 is instantiatedand designated for each tenant, different resources can be reserved fordifferent tenants. For example, Tenant A can be consistently allocated aminimum of four indexing nodes and Tenant B can be consistentlyallocated a minimum of two indexing nodes. In some such embodiments, thefour indexing nodes can be reserved for Tenant A and the two indexingnodes can be reserved for Tenant B, even if Tenant A and Tenant B arenot using the reserved indexing nodes.

In embodiments where an indexing system 212 is shared by multipletenants, different resources can be dynamically assigned to differenttenants. For example, if Tenant A has greater indexing demands,additional indexing nodes can be instantiated or assigned to Tenant A'sdata. However, as the demand decreases, the indexing nodes can bereassigned to a different tenant or terminated. Further, in someembodiments, a component of the indexing system 212, such as an ingestmanager 406, partition manager 408, and/or indexing node 404, canconcurrently process data from the different tenants.

In some embodiments, one instance of query system 214 may be shared bymultiple tenants. In some such cases, the same search head 504 can beused to process/execute queries for different tenants and/or the samesearch nodes 506 can be used to execute query for different tenants.Further, in some such cases, different tenants can be allocateddifferent amounts of compute resources. For example, Tenant A may beassigned more search heads 504 or search nodes 506 based on demand orbased on a service level arrangement than another tenant. However, oncea search is completed the search head and/or nodes assigned to Tenant Amay be assigned to Tenant B, deactivated, or their resource may bere-allocated to other components of the data intake and query system,etc.

In some cases, by sharing more components with different tenants, thefunctioning of the data intake and query system 108 can be improved. Forexample, by sharing components across tenants, the data intake and querysystem can improve resource utilization thereby reducing the amount ofresources allocated as a whole. For example, if four indexing nodes, twosearch heads, and four search nodes are reserved for each tenant thenthose compute resources are unavailable for use by other processes ortenants, even if they go unused. In contrast, by sharing the indexingnodes, search heads, and search nodes with different tenants andinstantiating additional compute resources, the data intake and querysystem can use fewer resources overall while providing improvedprocessing time for the tenants that are using the compute resources.For example, if tenant A is not using any search nodes 506 and tenant Bhas many searches running, the data intake and query system 214 can usesearch nodes that would have been reserved for tenant A to servicetenant B. In this way, the data intake and query system can decrease thenumber of compute resources used/reserved, while improving the searchtime for tenant B and improving compute resource utilization.

3.0. Data Intake and Query System Architecture

FIG. 2 is a block diagram of an embodiment of a data processingenvironment 200. In the illustrated embodiment, the environment 200includes data sources 202, client devices 204 a, 204 b . . . 204 n(generically referred to as client device(s) 204), and an applicationenvironment 205, in communication with a data intake and query system108 via networks 206, 208, respectively. The networks 206, 208 may bethe same network, may correspond to the network 104, or may be differentnetworks. Further, the networks 206, 208 may be implemented as one ormore LANs, WANs, cellular networks, intranetworks, and/or internetworksusing any of wired, wireless, terrestrial microwave, satellite links,etc., and may include the Internet.

Each data source 202 broadly represents a distinct source of data thatcan be consumed by the data intake and query system 108. Examples ofdata sources 202 include, without limitation, data files, directories offiles, data sent over a network, event logs, registries, streaming dataservices (examples of which can include, by way of non-limiting example,Amazon's Simple Queue Service (“SQS”) or Kinesis™ services, devicesexecuting Apache Kafka™ software, or devices implementing the MessageQueue Telemetry Transport (MQTT) protocol, Microsoft Azure EventHub,Google Cloud PubSub, devices implementing the Java Message Service (JMS)protocol, devices implementing the Advanced Message Queuing Protocol(AMQP)), performance metrics, cloud-based services (e.g., AWS, MicrosoftAzure, Google Cloud, etc.), operating-system-level virtualizationenvironments (e.g., Docker), container orchestration systems (e.g.,Kubernetes), virtual machines using full virtualization orparavirtualization, or other virtualization technique or isolatedexecution environments.

As illustrated in FIG. 2, in some embodiments, the data sources 202 cancommunicate with the data to the intake system 210 via the network 206without passing through the gateway 215. As a non-limiting example, ifthe intake system 210 receives the data from a data source 202 via aforwarder 302 (described in greater detail below), the intake system 210may receive the data via the network 206 without going through thegateway 215. In certain embodiments, the data sources 202 cancommunicate the data to the intake system 210 via the network 206 usingthe gateway 215. As another non-limiting example, if the intake system210 receives the data from a data source 202 via a HTTP intake point 322(described in greater detail below), it may receive the data via thegateway 215. Accordingly, it will be understood that a variety ofmethods can be used to receive data from the data sources 202 via thenetwork 206 or via the network 206 and the gateway 215.

The client devices 204 can be implemented using one or more computingdevices in communication with the data intake and query system 108 andrepresent some of the different ways in which computing devices cansubmit queries to the data intake and query system 108. For example, theclient device 204 a is illustrated as communicating over an Internet(Web) protocol with the data intake and query system 108, the clientdevice 204 b is illustrated as communicating with the data intake andquery system 108 via a command line interface, and the client device 204n is illustrated as communicating with the data intake and query system108 via a software developer kit (SDK). However, it will be understoodthat the client devices 204 can communicate with, and submit queries to,the data intake and query system 108 in a variety of ways. For example,the client devices 204 can use one or more executable applications orprograms from the application environment 205 to interface with the dataintake and query system 108. The application environment 205 can includetools, software modules (e.g., computer executable instructions toperform a particular function), etc., to enable application developersto create computer executable applications to interface with the dataintake and query system 108. For example, application developers canidentify particular data that is of particular relevance to them. Theapplication developers can use the application environment 205 to builda particular application to interface with the data intake and querysystem 108 to obtain the relevant data that they seek, process therelevant data, and display it in a manner that is consumable or easilyunderstood by a user. The applications developed using the applicationenvironment 205 can include their own backend services, middlewarelogic, front-end user interface, etc., and can provide facilities foringesting use case specific data and interacting with that data.

In certain embodiments, the developed applications can be executed by acomputing device or in an isolated execution environment of an isolatedexecution environment system, such as Kubernetes, AWS, Microsoft Azure,Google Cloud, etc. In addition, some embodiments, the applicationenvironments 205 can provide one or more isolated execution environmentsin which to execute the developed applications. In some cases, theapplications are executed in an isolated execution environment or aprocessing device unrelated to the application environment 205.

As a non-limiting example, an application developed using theapplication environment 205 can include a custom web-user interface thatmay or may not leverage one or more UI components provided by theapplication environment 205. The application could include middle-warebusiness logic, on a middle-ware platform of the developer's choice.Furthermore, as mentioned the applications implemented using theapplication environment 205 can be instantiated and execute in adifferent isolated execution environment or different isolated executionenvironment system than the data intake and query system 108. As anon-limiting example, in embodiments where the data intake and querysystem 108 is implemented using a Kubernetes cluster, the applicationsdeveloped using the application environment 205 can execute in adifferent Kubernetes cluster (or other isolated execution environmentsystem) and interact with the data intake and query system 108 via thegateway 215.

The data intake and query system 108 can process and store data receiveddata from the data sources 202 and execute queries on the data inresponse to requests received from the client devices 204. In theillustrated embodiment, the data intake and query system 108 includes agateway 209, an intake system 210, an indexing system 212, a querysystem 214, common storage 216 including one or more data stores 218, adata store catalog 220, a metadata catalog 221, and a query accelerationdata store 222. Although certain communication pathways are illustratedin FIG. 2, it will be understood that, in certain embodiments, anycomponent of the data intake and query system 108 can interact with anyother component of the data intake and query system 108. For example,the gateway 215 can interact with one or more components of the indexingsystem 212 and/or one or more components of the intake system 210 cancommunicate with the metadata catalog 221. Thus, data and/or commandscan be communicated in a variety of ways within the data intake andquery system 108.

As will be described in greater detail herein, the gateway 215 canprovide an interface between one or more components of the data intakeand query system 108 and other systems or computing devices, such as,but not limited to, client devices 204, the application environment 205,one or more data sources 202, and/or other systems 262. In someembodiments, the gateway 215 can be implemented using an applicationprogramming interface (API). In certain embodiments, the gateway 215 canbe implemented using a representational state transfer API (REST API).

As mentioned, the data intake and query system 108 can receive data fromdifferent sources 202. In some cases, the data sources 202 can beassociated with different tenants or customers. Further, each tenant maybe associated with one or more indexes, hosts, sources, sourcetypes, orusers. For example, company ABC, Inc. can correspond to one tenant andcompany XYZ, Inc. can correspond to a different tenant. While the twocompanies may be unrelated, each company may have a main index and testindex (also referred to herein as a main partition or test partition)associated with it, as well as one or more data sources or systems(e.g., billing system, CRM system, etc.). The data intake and querysystem 108 can concurrently receive and process the data from thevarious systems and sources of ABC, Inc. and XYZ, Inc.

In certain cases, although the data from different tenants can beprocessed together or concurrently, the data intake and query system 108can take steps to avoid combining or co-mingling data from the differenttenants. For example, the data intake and query system 108 can assign atenant identifier for each tenant and maintain a separation between thedata using the tenant identifier. In some cases, the tenant identifiercan be assigned to the data at the data sources 202 or can be assignedto the data by the data intake and query system 108 at ingest.

As will be described in greater detail herein, at least with referenceto FIGS. 3A and 3B, the intake system 210 can receive data from the datasources 202, perform one or more preliminary processing operations onthe data, and communicate the data to the indexing system 212, querysystem 214, or to other systems 262 (which may include, for example,data processing systems, telemetry systems, real-time analytics systems,data stores, databases, etc., any of which may be operated by anoperator of the data intake and query system 108 or a third party).

The intake system 210 can receive data from the data sources 202 in avariety of formats or structures. In some embodiments, the received datacorresponds to raw machine data, structured or unstructured data,correlation data, data files, directories of files, data sent over anetwork, event logs, registries, messages published to streaming datasources, performance metrics, sensor data, image and video data, etc.

The intake system 210 can process the data based on the form in which itis received. In some cases, the intake system 210 can utilize one ormore rules to process data and to make the data available to downstreamsystems (e.g., the indexing system 212, query system 214, etc.).Illustratively, the intake system 210 can enrich the received data. Forexample, the intake system may add one or more fields to the datareceived from the data sources 202, such as fields denoting the host,source, sourcetype, index, or tenant associated with the incoming data.In certain embodiments, the intake system 210 can perform additionalprocessing on the incoming data, such as transforming structured datainto unstructured data (or vice versa), identifying timestampsassociated with the data, removing extraneous data, parsing data,indexing data, separating data, categorizing data, routing data based oncriteria relating to the data being routed, and/or performing other datatransformations, etc.

In some cases, the data processed by the intake system can becommunicated or made available to the indexing system 212, the querysystem 214, and/or to other systems 262. In some embodiments, the intakesystem 210 communicates or makes available streams of data using one ormore shards or partitions. For example, the indexing system 212 may reador receive data from one shard and another system may receive data fromanother shard. As another example, multiple systems may receive datafrom the same shard or partition.

As used herein, a partition can refer to a logical division of data. Insome cases, the logical division of data may refer to a portion of adata stream, such as a shard from the intake system 210. In certaincases, the logical division of data can refer to an index or otherportion of data stored in the data store 412 or common storage 216, suchas different directories or file structures used to store data orbuckets. Accordingly, it will be understood that the logical division ofdata referenced by the term partition will be understood based on thecontext of its use.

As will be described in greater detail herein, at least with referenceto FIGS. 4A and 4B, the indexing system 212 can process the data andstore it, for example, in common storage 216. As part of processing thedata, the indexing system can identify timestamps associated with thedata, organize the data into buckets or time series buckets, converteditable buckets to non-editable buckets, store copies of the buckets incommon storage 216, merge buckets, generate indexes of the data, etc. Inaddition, the indexing system 212 can update the data store catalog 220with information related to the buckets (pre-merged or merged) or datathat is stored in common storage 216, and can communicate with theintake system 210 about the status of the data storage.

As will be described in greater detail herein, at least with referenceto FIG. 5, the query system 214 can receive queries that identify a setof data to be processed and a manner of processing the set of data fromone or more client devices 204, process the queries to identify the setof data, and execute the query on the set of data. In some cases, aspart of executing the query, the query system 214 can use the data storecatalog 220 to identify the set of data to be processed or its locationin common storage 216 and/or can retrieve data from common storage 216or the query acceleration data store 222. In addition, in someembodiments, the query system 214 can store some or all of the queryresults in the query acceleration data store 222.

As mentioned and as will be described in greater detail below, thecommon storage 216 can be made up of one or more data stores 218 storingdata that has been processed by the indexing system 212. The commonstorage 216 can be configured to provide high availability, highlyresilient, low loss data storage. In some cases, to provide the highavailability, highly resilient, low loss data storage, the commonstorage 216 can store multiple copies of the data in the same anddifferent geographic locations and across different types of data stores(e.g., solid state, hard drive, tape, etc.). Further, as data isreceived at the common storage 216 it can be automatically replicatedmultiple times according to a replication factor to different datastores across the same and/or different geographic locations. In someembodiments, the common storage 216 can correspond to cloud storage,such as Amazon Simple Storage Service (S3) or Elastic Block Storage(EBS), Google Cloud Storage, Microsoft Azure Storage, etc.

In some embodiments, indexing system 212 can read to and write from thecommon storage 216. For example, the indexing system 212 can copybuckets of data from its local or shared data stores to the commonstorage 216. In certain embodiments, the query system 214 can read from,but cannot write to, the common storage 216. For example, the querysystem 214 can read the buckets of data stored in common storage 216 bythe indexing system 212, but may not be able to copy buckets or otherdata to the common storage 216. In some embodiments, the intake system210 does not have access to the common storage 216. However, in someembodiments, one or more components of the intake system 210 can writedata to the common storage 216 that can be read by the indexing system212.

As described herein, in some embodiments, data in the data intake andquery system 108 (e.g., in the data stores of the indexers of theindexing system 212, common storage 216, or search nodes of the querysystem 214) can be stored in one or more time series buckets. Eachbucket can include raw machine data associated with a time stamp andadditional information about the data or bucket, such as, but notlimited to, one or more filters, indexes (e.g., TSIDX, inverted indexes,keyword indexes, etc.), bucket summaries, etc. In some embodiments, thebucket data and information about the bucket data is stored in one ormore files. For example, the raw machine data, filters, indexes, bucketsummaries, etc. can be stored in respective files in or associated witha bucket. In certain cases, the group of files can be associatedtogether to form the bucket.

The data store catalog 220 can store information about the data storedin common storage 216, such as, but not limited to an identifier for aset of data or buckets, a location of the set of data, tenants orindexes associated with the set of data, timing information about thedata, etc. For example, in embodiments where the data in common storage216 is stored as buckets, the data store catalog 220 can include abucket identifier for the buckets in common storage 216, a location ofor path to the bucket in common storage 216, a time range of the data inthe bucket (e.g., range of time between the first-in-time event of thebucket and the last-in-time event of the bucket), a tenant identifieridentifying a customer or computing device associated with the bucket,and/or an index (also referred to herein as a partition) associated withthe bucket, etc. In certain embodiments, the data intake and querysystem 108 includes multiple data store catalogs 220. For example, insome embodiments, the data intake and query system 108 can include adata store catalog 220 for each tenant (or group of tenants), eachpartition of each tenant (or group of indexes), etc. In some cases, thedata intake and query system 108 can include a single data store catalog220 that includes information about buckets associated with multiple orall of the tenants associated with the data intake and query system 108.

The indexing system 212 can update the data store catalog 220 as theindexing system 212 stores data in common storage 216. Furthermore, theindexing system 212 or other computing device associated with the datastore catalog 220 can update the data store catalog 220 as theinformation in the common storage 216 changes (e.g., as buckets incommon storage 216 are merged, deleted, etc.). In addition, as describedherein, the query system 214 can use the data store catalog 220 toidentify data to be searched or data that satisfies at least a portionof a query. In some embodiments, the query system 214 makes requests toand receives data from the data store catalog 220 using an applicationprogramming interface (“API”).

As will be described in greater detail herein, at least with referenceto FIGS. 6 and 22-27, the metadata catalog 221 can store informationabout datasets used or supported by the data intake and query system 108and/or one or more rules that indicate which data in a dataset toprocess and how to process the data from the dataset. The informationabout the datasets can include configuration information, such as, butnot limited to the type of the dataset, access and authorizationinformation for the dataset, location information for the dataset,physical and logical names or other identifiers for the dataset, etc.The rules can indicate how different data of a dataset is to beprocessed and/or how to extract fields or field values from differentdata of a dataset.

The metadata catalog 221 can also include one or more datasetassociation records. The dataset association records can indicate how torefer to a particular dataset (e.g., a name or other identifier for thedataset) and/or identify associations or relationships between theparticular dataset and one or more rules or other datasets. In someembodiments, a dataset association record can be similar to a namespacein that it can indicate a scope of one or more datasets and the mannerin which to reference the one or more datasets. As a non-limitingexample, one dataset association record can identify four datasets: a“main” index dataset, a “test” index dataset, a “username” collectiondataset, and a “username” lookup dataset. The dataset association recordcan also identify one or more rules for one or more of the datasets. Forexample, one rule can indicate that for data with the sourcetype “foo”from the “main” index dataset (or all datasets of the datasetassociation record), multiple actions are to take place, such as,extracting a field value for a “UID” field, and using the “username”lookup dataset to identify a username associated with the extracted“UID” field value. The actions of the rule can provide specific guidanceas to how to extract the field value for the “UID” field from thesourcetype “foo” data in the “main” index dataset and how to perform thelookup of the username.

As described herein, the query system 214 can use the metadata catalog221 to, among other things, interpret dataset identifiers in a query,verify/authenticate a user's permissions and/or authorizations fordifferent datasets, identify additional processing as part of the query,identify one or more datasets from which to retrieve data as part of thequery (also referred to herein as source datasets), determine how toextract data from datasets, identifyconfigurations/definitions/dependencies to be used by search nodes toexecute the query, etc.

In certain embodiments, the query system 214 can use the metadatacatalog 221 to provide a stateless search service. For example, thequery system 214 can use the metadata catalog 221 to dynamicallydetermine the dataset configurations and rule configurations to be usedto execute a query (also referred to herein as the query configurationparameters) and communicate the query configuration parameters to one ormore search heads 504. If the query system 214 determines that anassigned search head 504 becomes unavailable, the query system 214 cancommunicate the dynamically determined query configuration parameters(and query to be executed) to another search head 504 without data lossand/or with minimal or reduced time loss.

In some embodiments, the metadata catalog 221 can be implemented using adatabase system, such as, but not limited to, a relational databasesystem (non-limiting commercial examples: DynamoDB, Aurora DB, etc.). Incertain embodiments, the database system can include entries for thedifferent datasets, rules, and/or dataset association records. Moreover,as described herein, the metadata catalog 221 can be modified over timeas information is learned about the datasets associated with or managedby the data intake and query system 108. For example, the entries in thedatabase system can include manual or system annotations, as describedherein.

The query acceleration data store 222 can store the results or partialresults of queries, or otherwise be used to accelerate queries. Forexample, if a user submits a query that has no end date, the querysystem 214 can store an initial set of results in the query accelerationdata store 222. As additional query results are determined based onadditional data, the additional results can be combined with the initialset of results, and so on. In this way, the query system 214 can avoidre-searching all of the data that may be responsive to the query andinstead search the data that has not already been searched.

3.1. Gateway and Authentication Flow

As described herein, the gateway 215 can provide an interface betweenone or more components of the data intake and query system 108(non-limiting examples: one or more components of the intake system 210,one or more components of the indexing system 212, one or morecomponents of the query system 214, common storage 216, the data storecatalog 220, the metadata catalog 221 and/or the acceleration data store222), and other systems or computing devices, such as, but not limitedto, client devices 204, the application environment 205, one or moredata sources 202, and/or other systems 262 (not illustrated). In somecases, one or more components of the data intake and query system 108can include their own API. In such embodiments, the gateway 215 cancommunicate with the API of a component of the data intake and querysystem 108. Accordingly, the gateway 215 can translate requests receivedfrom an external device into a command understood by the API of thespecific component of the data intake and query system 108. In this way,the gateway 215 can provide an interface between external devices andthe API of the devices of the data intake and query system 108. In someimplementations, components of the query system or other components maynot be reachable through the gateway, or may be separatelyaccess-controlled. For example, in some implementations, the resourcecatalog(s) 418, 508 and the resource monitor(s) 420, 510 may beinaccessible from outside the gateway, and may be accessed by internalcomponents.

In some embodiments, the gateway 215 can be implemented using an API,such as the REST API. In some such embodiments, the client devices 204can communicate via one or more commands, such as GET, PUT, etc.However, it will be understood that the gateway 215 can be implementedin a variety of ways to enable the external devices and/or systems tointerface with one or more components of the data intake and querysystem 108.

In certain embodiments, a client device 204 can provide controlparameters to the data intake and query system 108 via the gateway 215.As a non-limiting example, using the gateway 215, a client device 204can provide instructions to the metadata catalog 221, the intake system210, indexing system 212, and/or the query system 214. For example,using the gateway 215, a client device 204 can instruct the metadatacatalog 221 to add/modify/delete a dataset association record, dataset,rule, configuration, and/or action, etc. As another example, using thegateway 215, a client device 204 can provide a query to the query system214 and receive results. As yet another example, using the gateway 215,a client device 204 can provide processing instructions to the intakesystem 210. As yet another example, using the gateway 215, one or moredata sources 202 can provide data to the intake system 210. In someembodiments, one or more components of the intake system 210 can receivedata from a data source 202 via the gateway 215. For example, in someembodiments, data received by the HTTP intake point 322 and/or customintake points 332 (described in greater detail below) of the intakesystem 210 can be received via the gateway 215.

As mentioned, upon receipt of a request or command from an externaldevice, the gateway 215 can determine the component of the data intakeand query system 108 (or service) to handle the request. In someembodiments, the request or command can include an identifier for thecomponent associated with the request or command In certain embodiments,the gateway 215 can determine the component to handle the request basedon the type of request or services requested by the command. Forexample, if the request or command relates to (or includes) a query, thegateway 215 can determine that the command is to be sent to a componentof the query system 214. As another example, if the request or commandincludes data, such as raw machine data, metrics, or metadata, thegateway 215 can determine that the request or command is to be sent to acomponent of the intake system 210 (non-limiting examples: HTTP intakepoint 322 or other push-based publisher 320, custom intake point 332A orother pull-based publisher 330, etc.) or indexing system 212(non-limiting example: indexing node 404, etc.). As yet another example,if the gateway 215 determines that the request or command relates to themodification of a dataset or rule, it can communicate the command orrequest to the metadata catalog 221.

Furthermore, in some cases, the gateway 215 can translate the request orcommand received from the external device into a command that can beinterpreted by the component of the data intake and query system 108.For example, the request or command received by the gateway 215 may notbe interpretable or understood by the component of the data intake andquery system 108 that is to process the command or request. Moreover, asmentioned, in certain embodiments, one or more components of the dataintake and query system 108 can use an API to interact with othercomponents of the data intake and query system 108. Accordingly, thegateway 215 can generate a command for the component of the data intakeand query system 108 that is to process the command or request based onthe received command or request and the information about the API of thecomponent of the data intake and query system 108 (or the componentitself).

In some cases, the gateway 215 can expose a subset of components and/ora limited number of features of the components of the data intake andquery system 108 to the external devices. For example, for the querysystem 214, the gateway 215, may expose the ability to submit queriesbut may not expose the ability to configure certain components of thequery system 214, such as the resource catalog 510, resource monitor508, and/or cache manager 516 (described in greater detail below).However, it will be understood that the gateway 215 can be configured toexpose fewer or more components and/or fewer or more functions for thedifferent components as desired. By limiting the components or commandsfor the components of the data intake and query system, the gateway 215can provide improved security for the data intake and query system 108.

In addition to limiting the components or functions made available toexternal systems, the gateway 215 can provide authentication and/orauthorization functionality. For example, with each request or commandreceived by a client device and/or data source 202, the gateway 215 canauthenticate the computing device from which the requester command wasreceived and/or determine whether the requester has sufficientpermissions or authorizations to make the request. In this way, thegateway 215 can provide additional security for the data intake andquery system 108.

In some cases, the system 108 receives the request via an API. Forexample, a user can request access by entering a command that issues anAPI call to the system 108. In some cases, the API call or request caninclude the user's login information, such as a username and password,biometric data, or other credential, etc. In certain embodiments, theuser's computer can make the API call based on a user accessing aparticular URL or IP address, or entering login credentials on a webpageor login page.

In certain embodiments, the system 108 can authenticate the user byproviding the credentials to an external authentication system thatauthenticates the user, etc. Based on a match of the receivedcredentials with credentials of a known user, the system 108 canauthenticate the user. In some cases, as part of authenticating the userthe system 108 can determine the permissions of the users, such as, thedatasets, or components of the system 108 that the user can access. Insome cases, users can have different permissions to different componentsof the system. For example, one user may have access to the intakesystem 210, indexing system 212, and query system 214, and another usermay only have access to the query system 214. As another example, oneuser may be identified as an administrator and have permissions toaccess and/or modify configuration files, etc., and another user mayonly have read-only permissions in order to execute queries and receiveresults of the queries.

After a user is authenticated, the system 108 may receive a request fora component of the data intake and query system 108. For example, therequest may include a command to execute a query, modify/add/delete datain the metadata catalog 221 (e.g., dataset, rule, dataset associationrecord, dataset configuration record, rule configuration record, datasource, tenant information, user information, etc.), modify userpermissions, process data, or modify a processing flow of data, etc. Insome embodiments, the request for access and the request for thecomponent can be part of the same API call or same request. For example,a request may include the login credentials of a user and a command forthe component, etc.

Based on the authentication of the user, the system 108 can communicatethe request to the component. In certain embodiments, the system 108 canmodify the received request. For example, the component to receive therequest may have its own API that uses different syntax or commands thanthe API of the system 108. In some such cases, the system 108 can modifythe request for the component so that the component can properlyunderstand the request and execute the action associated with therequest. Furthermore, the component may require additional informationthat is not available to the user. In some such cases, the system 108can include the additional information to the component.

In certain embodiments, a request may involve multiple components of thedata intake and query system 108. In some cases, the components canperform the action concurrently or sequentially. For example someactions may require that different steps be performed sequentially andothers may allow for steps to be performed concurrently. In either case,the different components of the system can perform relevant actionsbased on the authentication by the system 108 and/or an authenticationby the individual components, etc. In some embodiments, the component(s)can authenticate the user before performing the action. In some suchembodiments, the component(s) can authenticate the user in a mannersimilar to that done by the system 108.

3.2. Intake System

As detailed below, data may be ingested at the data intake and querysystem 108 through an intake system 210 configured to conductpreliminary processing on the data, and make the data available todownstream systems or components, such as the indexing system 212, querysystem 214, third party systems, etc.

One example configuration of an intake system 210 is shown in FIG. 3A.As shown in FIG. 3A, the intake system 210 includes a forwarder 302, adata retrieval subsystem 304, an intake ingestion buffer 306, astreaming data processor 308, and an output ingestion buffer 310. Asdescribed in detail below, the components of the intake system 210 maybe configured to process data according to a streaming data model, suchthat data ingested into the data intake and query system 108 isprocessed rapidly (e.g., within seconds or minutes of initial receptionat the intake system 210) and made available to downstream systems orcomponents. The initial processing of the intake system 210 may includesearch or analysis of the data ingested into the intake system 210. Forexample, the initial processing can transform data ingested into theintake system 210 sufficiently, for example, for the data to be searchedby a query system 214, thus enabling “real-time” searching for data onthe data intake and query system 108 (e.g., without requiring indexingof the data). Various additional and alternative uses for data processedby the intake system 210 are described below.

Although shown as separate components, the forwarder 302, data retrievalsubsystem 304, intake ingestion buffer 306, streaming data processors308, and output ingestion buffer 310, in various embodiments, may resideon the same machine or be distributed across multiple machines in anycombination. In one embodiment, any or all of the components of theintake system can be implemented using one or more computing devices asdistinct computing devices or as one or more container instances orvirtual machines across one or more computing devices. It will beappreciated by those skilled in the art that the intake system 210 mayhave more of fewer components than are illustrated in FIGS. 3A and 3B.In addition, the intake system 210 could include various web servicesand/or peer-to-peer network configurations or inter containercommunication network provided by an associated container instantiationor orchestration platform. Thus, the intake system 210 of FIGS. 3A and3B should be taken as illustrative. For example, in some embodiments,components of the intake system 210, such as the ingestion buffers 306and 310 and/or the streaming data processors 308, may be executed by onemore virtual machines implemented in a hosted computing environment. Ahosted computing environment may include one or more rapidly provisionedand released computing resources, which computing resources may includecomputing, networking and/or storage devices. A hosted computingenvironment may also be referred to as a cloud computing environment.Accordingly, the hosted computing environment can include anyproprietary or open source extensible computing technology, such asApache Flink or Apache Spark, to enable fast or on-demand horizontalcompute capacity scaling of the streaming data processor 308.

In some embodiments, some or all of the elements of the intake system210 (e.g., forwarder 302, data retrieval subsystem 304, intake ingestionbuffer 306, streaming data processors 308, and output ingestion buffer310, etc.) may reside on one or more computing devices, such as servers,which may be communicatively coupled with each other and with the datasources 202, query system 214, indexing system 212, or other components.In other embodiments, some or all of the elements of the intake system210 may be implemented as worker nodes as disclosed in U.S. patentapplication Ser. Nos. 15/665,159, 15/665,148, 15/665,187, 15/665,248,15/665,197, 15/665,279, 15/665,302, and 15/665,339, each of which isincorporated by reference herein in its entirety (hereinafter referredto as “the Incorporated Applications”).

As noted above, the intake system 210 can function to conductpreliminary processing of data ingested at the data intake and querysystem 108. As such, the intake system 210 illustratively includes aforwarder 302 that obtains data from a data source 202 and transmits thedata to a data retrieval subsystem 304. The data retrieval subsystem 304may be configured to convert or otherwise format data provided by theforwarder 302 into an appropriate format for inclusion at the intakeingestion buffer and transmit the message to the intake ingestion buffer306 for processing. Thereafter, a streaming data processor 308 mayobtain data from the intake ingestion buffer 306, process the dataaccording to one or more rules, and republish the data to either theintake ingestion buffer 306 (e.g., for additional processing) or to theoutput ingestion buffer 310, such that the data is made available todownstream components or systems. In this manner, the intake system 210may repeatedly or iteratively process data according to any of a varietyof rules, such that the data is formatted for use on the data intake andquery system 108 or any other system. As discussed below, the intakesystem 210 may be configured to conduct such processing rapidly (e.g.,in “real-time” with little or no perceptible delay), while ensuringresiliency of the data.

3.2.1. Forwarder

The forwarder 302 can include or be executed on a computing deviceconfigured to obtain data from a data source 202 and transmit the datato the data retrieval subsystem 304. In some implementations, theforwarder 302 can be installed on a computing device associated with thedata source 202 or directly on the data source 202. While a singleforwarder 302 is illustratively shown in FIG. 3A, the intake system 210may include a number of different forwarders 302. Each forwarder 302 mayillustratively be associated with a different data source 202. Aforwarder 302 initially may receive the data as a raw data streamgenerated by the data source 202. For example, a forwarder 302 mayreceive a data stream from a log file generated by an applicationserver, from a stream of network data from a network device, or from anyother source of data. In some embodiments, a forwarder 302 receives theraw data and may segment the data stream into “blocks”, possibly of auniform data size, to facilitate subsequent processing steps. Theforwarder 302 may additionally or alternatively modify data received,prior to forwarding the data to the data retrieval subsystem 304.Illustratively, the forwarder 302 may “tag” metadata for each datablock, such as by specifying a source, source type, or host associatedwith the data, or by appending one or more timestamp or time ranges toeach data block.

In some embodiments, a forwarder 302 may comprise a service accessibleto data sources 202 via a network 206. For example, one type offorwarder 302 may be capable of consuming vast amounts of real-time datafrom a potentially large number of data sources 202. The forwarder 302may, for example, comprise a computing device which implements multipledata pipelines or “queues” to handle forwarding of network data to dataretrieval subsystems 304.

3.2.2. Data Retrieval Subsystem

The data retrieval subsystem 304 illustratively corresponds to acomputing device which obtains data (e.g., from the forwarder 302), andtransforms the data into a format suitable for publication on the intakeingestion buffer 306. Illustratively, where the forwarder 302 segmentsinput data into discrete blocks, the data retrieval subsystem 304 maygenerate a message for each block, and publish the message to the intakeingestion buffer 306. Generation of a message for each block mayinclude, for example, formatting the data of the message in accordancewith the requirements of a streaming data system implementing the intakeingestion buffer 306, the requirements of which may vary according tothe streaming data system. In one embodiment, the intake ingestionbuffer 306 formats messages according to the protocol buffers method ofserializing structured data. Thus, the intake ingestion buffer 306 maybe configured to convert data from an input format into a protocolbuffer format. Where a forwarder 302 does not segment input data intodiscrete blocks, the data retrieval subsystem 304 may itself segment thedata. Similarly, the data retrieval subsystem 304 may append metadata tothe input data, such as a source, source type, or host associated withthe data.

Generation of the message may include “tagging” the message with variousinformation, which may be included as metadata for the data provided bythe forwarder 302, and determining a “topic” for the message, underwhich the message should be published to the intake ingestion buffer306. In general, the “topic” of a message may reflect a categorizationof the message on a streaming data system. Illustratively, each topicmay be associated with a logically distinct queue of messages, such thata downstream device or system may “subscribe” to the topic in order tobe provided with messages published to the topic on the streaming datasystem.

In one embodiment, the data retrieval subsystem 304 may obtain a set oftopic rules (e.g., provided by a user of the data intake and querysystem 108 or based on automatic inspection or identification of thevarious upstream and downstream components of the data intake and querysystem 108) that determine a topic for a message as a function of thereceived data or metadata regarding the received data. For example, thetopic of a message may be determined as a function of the data source202 from which the data stems. After generation of a message based oninput data, the data retrieval subsystem can publish the message to theintake ingestion buffer 306 under the determined topic.

While the data retrieval subsystem 304 is depicted in FIG. 3A asobtaining data from the forwarder 302, the data retrieval subsystem 304may additionally or alternatively obtain data from other sources, suchas from the data source 202 and/or via the gateway 209. In someinstances, the data retrieval subsystem 304 may be implemented as aplurality of intake points, each functioning to obtain data from one ormore corresponding data sources (e.g., the forwarder 302, data sources202, or any other data source), generate messages corresponding to thedata, determine topics to which the messages should be published, and topublish the messages to one or more topics of the intake ingestionbuffer 306.

One illustrative set of intake points implementing the data retrievalsubsystem 304 is shown in FIG. 3B. Specifically, as shown in FIG. 3B,the data retrieval subsystem 304 of FIG. 3A may be implemented as a setof push-based publishers 320 or a set of pull-based publishers 330. Theillustrative push-based publishers 320 operate on a “push” model, suchthat messages are generated at the push-based publishers 320 andtransmitted to an intake ingestion buffer 306 (shown in FIG. 3B asprimary and secondary intake ingestion buffers 306A and 306B, which arediscussed in more detail below). As will be appreciated by one skilledin the art, “push” data transmission models generally correspond tomodels in which a data source determines when data should be transmittedto a data target. A variety of mechanisms exist to provide “push”functionality, including “true push” mechanisms (e.g., where a datasource independently initiates transmission of information) and“emulated push” mechanisms, such as “long polling” (a mechanism wherebya data target initiates a connection with a data source, but allows thedata source to determine within a timeframe when data is to betransmitted to the data source).

As shown in FIG. 3B, the push-based publishers 320 illustrativelyinclude an HTTP intake point 322 and a data intake and query system(DIQS) intake point 324. The HTTP intake point 322 can include acomputing device configured to obtain HTTP-based data (e.g., asJavaScript Object Notation, or JSON messages) to format the HTTP-baseddata as a message, to determine a topic for the message (e.g., based onfields within the HTTP-based data), and to publish the message to theprimary intake ingestion buffer 306A. Similarly, the DIQS intake point324 can be configured to obtain data from a forwarder 302, to format theforwarder data as a message, to determine a topic for the message, andto publish the message to the primary intake ingestion buffer 306A. Inthis manner, the DIQS intake point 324 can function in a similar mannerto the operations described with respect to the data retrieval subsystem304 of FIG. 3A.

In addition to the push-based publishers 320, one or more pull-basedpublishers 330 may be used to implement the data retrieval subsystem304. The pull-based publishers 330 may function on a “pull” model,whereby a data target (e.g., the primary intake ingestion buffer 306A)functions to continuously or periodically (e.g., each n seconds) querythe pull-based publishers 330 for new messages to be placed on theprimary intake ingestion buffer 306A. In some instances, development ofpull-based systems may require less coordination of functionalitybetween a pull-based publisher 330 and the primary intake ingestionbuffer 306A. Thus, for example, pull-based publishers 330 may be morereadily developed by third parties (e.g., other than a developer of thedata intake a query system 108), and enable the data intake and querysystem 108 to ingest data associated with third party data sources 202.Accordingly, FIG. 3B includes a set of custom intake points 332A through332N, each of which functions to obtain data from a third-party datasource 202, format the data as a message for inclusion in the primaryintake ingestion buffer 306A, determine a topic for the message, andmake the message available to the primary intake ingestion buffer 306Ain response to a request (a “pull”) for such messages.

While the pull-based publishers 330 are illustratively described asdeveloped by third parties, push-based publishers 320 may also in someinstances be developed by third parties. Additionally or alternatively,pull-based publishers may be developed by the developer of the dataintake and query system 108. To facilitate integration of systemspotentially developed by disparate entities, the primary intakeingestion buffer 306A may provide an API through which an intake pointmay publish messages to the primary intake ingestion buffer 306A.Illustratively, the API may enable an intake point to “push” messages tothe primary intake ingestion buffer 306A, or request that the primaryintake ingestion buffer 306A “pull” messages from the intake point.Similarly, the streaming data processors 308 may provide an API throughwhich ingestions buffers may register with the streaming data processors308 to facilitate pre-processing of messages on the ingestion buffers,and the output ingestion buffer 310 may provide an API through which thestreaming data processors 308 may publish messages or through whichdownstream devices or systems may subscribe to topics on the outputingestion buffer 310. Furthermore, any one or more of the intake points322 through 332N may provide an API through which data sources 202 maysubmit data to the intake points. Thus, any one or more of thecomponents of FIGS. 3A and 3B may be made available via APIs to enableintegration of systems potentially provided by disparate parties.

The specific configuration of publishers 320 and 330 shown in FIG. 3B isintended to be illustrative in nature. For example, the specific numberand configuration of intake points may vary according to embodiments ofthe present application. In some instances, one or more components ofthe intake system 210 may be omitted. For example, a data source 202 mayin some embodiments publish messages to an intake ingestion buffer 306,and thus an intake point 332 may be unnecessary. Other configurations ofthe intake system 210 are possible.

3.2.3. Ingestion Buffer(s)

The intake system 210 is illustratively configured to ensure messageresiliency, such that data is persisted in the event of failures withinthe intake system 210. Specifically, the intake system 210 may utilizeone or more ingestion buffers, which operate to resiliently maintaindata received at the intake system 210 until the data is acknowledged bydownstream systems or components. In one embodiment, resiliency isprovided at the intake system 210 by use of ingestion buffers thatoperate according to a publish-subscribe (“pub-sub”) message model. Inaccordance with the pub-sub model, data ingested into the data intakeand query system 108 may be atomized as “messages,” each of which iscategorized into one or more “topics.” An ingestion buffer can maintaina queue for each such topic, and enable devices to “subscribe” to agiven topic. As messages are published to the topic, the ingestionbuffer can function to transmit the messages to each subscriber, andensure message resiliency until at least each subscriber hasacknowledged receipt of the message (e.g., at which point the ingestionbuffer may delete the message). In this manner, the ingestion buffer mayfunction as a “broker” within the pub-sub model. A variety of techniquesto ensure resiliency at a pub-sub broker are known in the art, and thuswill not be described in detail herein. In one embodiment, an ingestionbuffer is implemented by a streaming data source. As noted above,examples of streaming data sources include (but are not limited to)Amazon's Simple Queue Service (“SQS”) or Kinesis™ services, devicesexecuting Apache Kafka™ software, or devices implementing the MessageQueue Telemetry Transport (MQTT) protocol. Any one or more of theseexample streaming data sources may be utilized to implement an ingestionbuffer in accordance with embodiments of the present disclosure.

With reference to FIG. 3A, the intake system 210 may include at leasttwo logical ingestion buffers: an intake ingestion buffer 306 and anoutput ingestion buffer 310. As noted above, the intake ingestion buffer306 can be configured to receive messages from the data retrievalsubsystem 304 and resiliently store the message. The intake ingestionbuffer 306 can further be configured to transmit the message to thestreaming data processors 308 for processing. As further describedbelow, the streaming data processors 308 can be configured with one ormore data transformation rules to transform the messages, and republishthe messages to one or both of the intake ingestion buffer 306 and theoutput ingestion buffer 310. The output ingestion buffer 310, in turn,may make the messages available to various subscribers to the outputingestion buffer 310, which subscribers may include the query system214, the indexing system 212, or other third-party devices (e.g., clientdevices 102, host devices 106, etc.).

Both the input ingestion buffer 306 and output ingestion buffer 310 maybe implemented on a streaming data source, as noted above. In oneembodiment, the intake ingestion buffer 306 operates to maintainsource-oriented topics, such as topics for each data source 202 fromwhich data is obtained, while the output ingestion buffer operates tomaintain content-oriented topics, such as topics to which the data of anindividual message pertains. As discussed in more detail below, thestreaming data processors 308 can be configured to transform messagesfrom the intake ingestion buffer 306 (e.g., arranged according tosource-oriented topics) and publish the transformed messages to theoutput ingestion buffer 310 (e.g., arranged according tocontent-oriented topics). In some instances, the streaming dataprocessors 308 may additionally or alternatively republish transformedmessages to the intake ingestion buffer 306, enabling iterative orrepeated processing of the data within the message by the streaming dataprocessors 308.

While shown in FIG. 3A as distinct, these ingestion buffers 306 and 310may be implemented as a common ingestion buffer. However, use ofdistinct ingestion buffers may be beneficial, for example, where ageographic region in which data is received differs from a region inwhich the data is desired. For example, use of distinct ingestionbuffers may beneficially allow the intake ingestion buffer 306 tooperate in a first geographic region associated with a first set of dataprivacy restrictions, while the output ingestion buffer 310 operates ina second geographic region associated with a second set of data privacyrestrictions. In this manner, the intake system 210 can be configured tocomply with all relevant data privacy restrictions, ensuring privacy ofdata processed at the data intake and query system 108.

Moreover, either or both of the ingestion buffers 306 and 310 may beimplemented across multiple distinct devices, as either a single ormultiple ingestion buffers. Illustratively, as shown in FIG. 3B, theintake system 210 may include both a primary intake ingestion buffer306A and a secondary intake ingestion buffer 306B. The primary intakeingestion buffer 306A is illustratively configured to obtain messagesfrom the data retrieval subsystem 304 (e.g., implemented as a set ofintake points 322 through 332N). The secondary intake ingestion buffer306B is illustratively configured to provide an additional set ofmessages (e.g., from other data sources 202). In one embodiment, theprimary intake ingestion buffer 306A is provided by an administrator ordeveloper of the data intake and query system 108, while the secondaryintake ingestion buffer 306B is a user-supplied ingestion buffer (e.g.,implemented externally to the data intake and query system 108).

As noted above, an intake ingestion buffer 306 may in some embodimentscategorize messages according to source-oriented topics (e.g., denotinga data source 202 from which the message was obtained). In otherembodiments, an intake ingestion buffer 306 may in some embodimentscategorize messages according to intake-oriented topics (e.g., denotingthe intake point from which the message was obtained). The number andvariety of such topics may vary, and thus are not shown in FIG. 3B. Inone embodiment, the intake ingestion buffer 306 maintains only a singletopic (e.g., all data to be ingested at the data intake and query system108).

The output ingestion buffer 310 may in one embodiment categorizemessages according to content-centric topics (e.g., determined based onthe content of a message). Additionally or alternatively, the outputingestion buffer 310 may categorize messages according toconsumer-centric topics (e.g., topics intended to store messages forconsumption by a downstream device or system). An illustrative number oftopics are shown in FIG. 3B, as topics 342 through 352N. Each topic maycorrespond to a queue of messages (e.g., in accordance with the pub-submodel) relevant to the corresponding topic. As described in more detailbelow, the streaming data processors 308 may be configured to processmessages from the intake ingestion buffer 306 and determine which topicsof the topics 342 through 352N into which to place the messages. Forexample, the index topic 342 may be intended to store messages, or datarecords, holding data that should be consumed and processed by theindexing system 212. The notable event topic 344 may be intended tostore messages holding data that indicates a notable event at a datasource 202 (e.g., the occurrence of an error or other notable event).The metrics topic 346 may be intended to store messages holding metricsdata for data sources 202. The search results topic 348 may be intendedto store messages holding data responsive to a search query. The mobilealerts topic 350 may be intended to store messages holding data forwhich an end user has requested alerts on a mobile device. A variety ofcustom topics 352A through 352N may be intended to hold data relevant toend-user-created topics.

As will be described below, by application of message transformationrules at the streaming data processors 308, the intake system 210 maydivide and categorize messages from the intake ingestion buffer 306,partitioning or sharding the messages into output topics relevant to aspecific downstream consumer. In this manner, specific portions of datainput to the data intake and query system 108 may be “divided out” andhandled separately, enabling different types of data to be handleddifferently, and potentially at different speeds. Illustratively, theindex topic 342 may be configured to include all or substantially alldata included in the intake ingestion buffer 306. Given the volume ofdata, there may be a significant delay (e.g., minutes or hours) before adownstream consumer (e.g., the indexing system 212) processes a messagein the index topic 342. Thus, for example, searching data processed bythe indexing system 212 may incur significant delay.

Conversely, the search results topic 348 may be configured to hold onlymessages corresponding to data relevant to a current query.Illustratively, on receiving a query from a client device 204, the querysystem 214 may transmit to the intake system 210 a rule that detects,within messages from the intake ingestion buffer 306A, data potentiallyrelevant to the query. The streaming data processors 308 may republishthese messages within the search results topic 348, and the query system214 may subscribe to the search results topic 348 in order to obtain thedata within the messages. In this manner, the query system 214 can“bypass” the indexing system 212 and avoid delay that may be caused bythat system, thus enabling faster (and potentially real time) display ofsearch results.

While shown in FIGS. 3A and 3B as a single output ingestion buffer 310,the intake system 210 may in some instances utilize multiple outputingestion buffers 310.

As described herein, in some embodiments, components of the intakesystem 210 can be reserved for a particular tenant or shared by multipletenants. In some such embodiments, a separate output ingestion buffer310 can be instantiated for each tenant or used by multiple tenants. Inembodiments, where an output ingestion buffer 310 is assigned to aparticular tenant, the output ingestion buffer 310 process data fromonly one tenant. In some such embodiments, the output ingestion buffer310 may not receive or process data from any other tenants.

In certain embodiments, the output ingestion buffer 310 can be shared bymultiple tenants. In some such embodiments, a partition or shard of theoutput ingestion buffer can 310 include data records associated withdifferent tenants. For example, a first shard can include data recordsassociated with Tenant A and Tenant B. As another example, the firstshard may only include data from Tenant A and a second shard may onlyinclude data from Tenant B. In either case, the output ingestion buffer310 can concurrently process data from different tenants. In some suchembodiments, the output ingestion buffer 310 can provide the data fromdifferent tenants to the same or different components of the indexingsystem 212. For example, as described herein, the indexing system 212,or certain components thereof, can be reserved for a particular tenantor shared across multiple tenants. Accordingly, the output ingestionbuffer 310 may provide the data to an indexing system 212 of aparticular tenant or an indexing system 212 that is shared by multipletenants.

3.2.4. Streaming Data Processors

As noted above, the streaming data processors 308 may apply one or morerules to process messages from the intake ingestion buffer 306A intomessages on the output ingestion buffer 310. These rules may bespecified, for example, by an end user of the data intake and querysystem 108 or may be automatically generated by the data intake andquery system 108 (e.g., in response to a user query).

Illustratively, each rule may correspond to a set of selection criteriaindicating messages to which the rule applies, as well as one or moreprocessing sub-rules indicating an action to be taken by the streamingdata processors 308 with respect to the message. The selection criteriamay include any number or combination of criteria based on the dataincluded within a message or metadata of the message (e.g., a topic towhich the message is published). In one embodiment, the selectioncriteria are formatted in the same manner or similarly to extractionrules, discussed in more detail below. For example, selection criteriamay include regular expressions that derive one or more values or asub-portion of text from the portion of machine data in each message toproduce a value for the field for that message. When a message islocated within the intake ingestion buffer 306 that matches theselection criteria, the streaming data processors 308 may apply theprocessing rules to the message. Processing sub-rules may indicate, forexample, a topic of the output ingestion buffer 310 into which themessage should be placed. Processing sub-rules may further indicatetransformations, such as field or unit normalization operations, to beperformed on the message. Illustratively, a transformation may includemodifying data within the message, such as altering a format in whichthe data is conveyed (e.g., converting millisecond timestamps values tomicrosecond timestamp values, converting imperial units to metric units,etc.), or supplementing the data with additional information (e.g.,appending an error descriptor to an error code). In some instances, thestreaming data processors 308 may be in communication with one or moreexternal data stores (the locations of which may be specified within arule) that provide information used to supplement or enrich messagesprocessed at the streaming data processors 308. For example, a specificrule may include selection criteria identifying an error code within amessage of the primary ingestion buffer 306A, and specifying that whenthe error code is detected within a message, that the streaming dataprocessors 308 should conduct a lookup in an external data source (e.g.,a database) to retrieve the human-readable descriptor for that errorcode, and inject the descriptor into the message. In this manner, rulesmay be used to process, transform, or enrich messages.

The streaming data processors 308 may include a set of computing devicesconfigured to process messages from the intake ingestion buffer 306 at aspeed commensurate with a rate at which messages are placed into theintake ingestion buffer 306. In one embodiment, the number of streamingdata processors 308 used to process messages may vary based on a numberof messages on the intake ingestion buffer 306 awaiting processing.Thus, as additional messages are queued into the intake ingestion buffer306, the number of streaming data processors 308 may be increased toensure that such messages are rapidly processed. In some instances, thestreaming data processors 308 may be extensible on a per topic basis.Thus, individual devices implementing the streaming data processors 308may subscribe to different topics on the intake ingestion buffer 306,and the number of devices subscribed to an individual topic may varyaccording to a rate of publication of messages to that topic (e.g., asmeasured by a backlog of messages in the topic). In this way, the intakesystem 210 can support ingestion of massive amounts of data fromnumerous data sources 202.

In some embodiments, an intake system 210 may comprise a serviceaccessible to client devices 102 and host devices 106 via a network 104.For example, one type of forwarder 302 may be capable of consuming vastamounts of real-time data from a potentially large number of clientdevices 102 and/or host devices 106. The forwarder may, for example,comprise a computing device which implements multiple data pipelines or“queues” to handle forwarding of network data to indexers. A forwarder302 may also perform many of the functions that are performed by anindexer. For example, a forwarder 302 may perform keyword extractions onraw data or parse raw data to create events. A forwarder 302 maygenerate time stamps for events. Additionally or alternatively, aforwarder 302 may perform routing of events to indexers. Data store 208may contain events derived from machine data from a variety of sourcesall pertaining to the same component in an IT environment, and this datamay be produced by the machine in question or by other components in theIT environment.

3.3. Indexing System

FIGS. 4A and 4B are block diagrams illustrating embodiment of anindexing system 212. As described herein, in some embodiments, anindexing system 212 can be instantiated for each distinct tenant. Forexample, in some cases, the embodiment of the indexing system 212illustrated in FIG. 4A can be configured for a single tenant. In somesuch cases, each tenant can be assigned a separate indexing systemmanager 402, bucket manager 414, and indexing node(s) 404, includingseparate ingest manager(s) 406, partition managers 408, indexers 410,and data stores 412, etc. In such embodiments, the indexing node(s) 404,ingest manager(s) 406, and partition managers 408 may only process dataassociated with one tenant.

In certain embodiments, one or more components of the indexing systemcan be shared between multiple tenants. For example, in certain cases,the embodiment of the indexing system 212 illustrated in FIG. 4B can beconfigured for use by tenants. In some such cases, an ingest manager406, partition manager 408, and/or indexing node 404 may concurrentlyreceive and process data from multiple tenants. In addition, in theillustrated embodiment of FIG. 4B, the indexing system 212 can include aresource monitor 418 and a resource catalog 420.

It will be understood that the indexing system 212 can include fewer ormore components. For example, in some embodiments, the common storage216, the bucket manager 414, or the data store catalog 220 can form partof the indexing system 212, etc. In addition, although illustrated aspart of the indexing system 212, it will be understood that the resourcemonitor 418 and the resource catalog 420 can, in some embodiments, beseparate or independent of the indexing system 212. For example, incertain embodiments, the indexing system 212 and/or query system 214 cancommunicate with the resource monitor 418 and resource catalog 420similar to the way in which the indexing system 212 and query system 214can communicate with the data store catalog 220 and/or metadata catalog221.

As detailed herein, the ingestion buffer 310 communicates one or moredata streams to the indexing system 212 using multiple shards orpartitions. The data from a particular partition can be referred to as,or include, one or more data records. In some cases, the data recordsfrom a particular partition correspond to data associated with differenttenants, users, etc. In certain embodiments, the data records caninclude data to be processed by the indexing system 212 to generate oneor more events or location information of the data to be processed bythe indexing system 212 to generate one or more events. For example, thedata records can include a file identifier and a pointer to the locationof a file that includes the data to be processed by the indexing system212 to generate one or more events. In some embodiments, the datarecords can include a tenant identifier that identifies the tenantassociated with the file or data to be processed.

The indexing system 212 can receive, process, and store datacorresponding to the shards or partitions. For example, the indexingsystem 212 can generate events that include a portion of machine dataassociated with a timestamp and store the events in buckets based on oneor more of the timestamps, tenants, indexes, etc., associated with thedata. Moreover, the indexing system 212 can include various componentsthat enable it to provide a stateless indexing service, or indexingservice that is able to rapidly recover without data loss if one or morecomponents of the indexing system 212 become unresponsive orunavailable.

As described herein, each of the components of the indexing system 212can be implemented using one or more computing devices as distinctcomputing devices or as one or more container instances or virtualmachines across one or more computing devices. For example, in someembodiments, one or more the indexing system managers 402, the bucketmanagers 414, the resource catalog 420, the resource monitors 418, theingest managers 406, and/or the indexing nodes 404 can be implemented asdistinct computing devices with separate hardware, memory, andprocessors. In certain embodiments, one or more indexing system managers402, bucket managers 414, resource catalogs 420, resource monitors 418,ingest managers 406, and/or indexing nodes 404 can be implemented on thesame or across different computing devices as distinct containerinstances, with each container having access to a subset of theresources of a host computing device (e.g., a subset of the memory orprocessing time of the processors of the host computing device), butsharing a similar operating system. In some cases, the components can beimplemented as distinct virtual machines across one or more computingdevices, where each virtual machine can have its own unshared operatingsystem but shares the underlying hardware with other virtual machines onthe same host computing device.

3.3.1. Indexing System Manager

The indexing system manager 402 can monitor and manage the indexingnodes 404, and can be implemented as a distinct computing device,virtual machine, container, container of a pod, or a process or threadassociated with a container. For example, the indexing system manager402 can determine whether to generate an additional indexing node 404based on a utilization rate or availability of the indexing nodes 404.In certain embodiments, the indexing system 212 can include one indexingsystem manager 402 to manage all indexing nodes 404 of the indexingsystem 212. In some embodiments, the indexing system 212 can includemultiple indexing system managers 402 to manage the indexing nodes 404of the indexing system 212. For example, an indexing system manager 402can be instantiated for each computing device (or group of computingdevices) configured as a host computing device for multiple indexingnodes 404.

The indexing system manager 402 can handle resource management,creation/destruction of indexing nodes 404, high availability, loadbalancing, application upgrades/rollbacks, logging and monitoring,storage, networking, service discovery, and performance and scalability,and otherwise handle containerization management of the containers ofthe indexing system 212. In certain embodiments, the indexing systemmanager 402 can be implemented using Kubernetes or Swarm.

In some cases, the indexing system manager 402 can monitor the availableresources of a host computing device and request additional resources ina shared resource environment, based on workload of the indexing nodes404 or create, destroy, or reassign indexing nodes 404 based onworkload. Further, in some cases, the indexing system manager 402 systemcan assign indexing nodes 404 to handle data streams based on workload,system resources, etc. For example, in certain embodiments, the indexingsystem manager 402 can monitor or communicate with the resource catalog420 to identify workload of one or more of the indexing nodes 404.

In some embodiments, such as where ingest manager(s) 406 areinstantiated in a different isolated execution environment, container,or pod from the indexing nodes 404 (a non-limiting example isillustrated in FIG. 4B), the indexing system manager 402 can alsoperform any one or any combination of the aforementioned functions withrespect to the ingest manager(s) 406. In some such embodiments, theindexing system 212 can include one indexing system manager 402 tomanage the indexing nodes 404 and a second indexing system manager 402to manage the ingest managers 406. However, it will be understood thatin some cases a single indexing system manager 402 can manage theindexing nodes 404 and the ingest manager(s) 406 as desired.

3.3.2. Ingest Manager

One or more ingest managers 406 can receive the one or more data streamsfrom the partitions (or shards). Each ingest manager 406 can beimplemented as a distinct computing device, virtual machine, container,container of a pod, or a process or thread associated with a container.For example, in the illustrated embodiment of FIG. 4A, the ingestmanager 406 is shown as part of an indexing node 404, such as acontainer of an indexing node pod. As another example, in theillustrated embodiment of FIG. 4A, the ingest manager 406 is shown asbeing separate from the indexing nodes 404, such as a container or podthat is separate from the indexing node container or pod.

Depending on the architecture of the indexing system 212, the functionsof the ingest manager can vary. For example, when implemented as part ofan indexing node, the ingest manager 406 can be used to distribute thedata of one tenant between the indexing nodes 404 of that tenant. Insuch embodiments, the ingest manager can manage the processing of thedata of the data stream(s) of a tenant by the indexing nodes 404 of thattenant. In some such embodiments, each indexing node 404 can include oneor more ingest managers 406.

When instantiated separately from the indexing node 404, such as in ashared computing resource environment, the ingest manager(s) 406 can beused to distribute data associated with different tenants to differentindexing nodes 404. In addition, in some such embodiments, the ingestmanager(s) 406 be scaled separately or independently from the indexingnodes 404. For example, in some cases, the ingest manager 406 can have a1:1 correspondence to indexing nodes 404. In other cases, the ingestmanagers 406 can have a one-to-many or many-to-one correspondence toindexing nodes 404. As will be described herein, in some cases, wheninstantiated separately from the indexing nodes, the ingest manager (orpartition managers 408) can concurrently process data from multipletenants and communicate the data from multiple tenants to differentindexing nodes 404, each of which can concurrently process data fromdifferent tenants.

In certain embodiments, an ingest manager 406 can generate one or morepartition managers 408 to manage the partitions or streams of datareceived from the intake system 210. For example, the ingest manager 406can generate or assign a separate partition manager 408 for eachpartition or shard received from an output ingestion buffer 310. Asanother example, the ingest manager 406 can generate or assign a singlepartition manager 408 for multiple partitions.

In certain embodiments, data records can include a location marker. Forexample, the ingest manager 406 or partition manager 408 can receive(and/or store) the location markers in addition to or as part of thedata records received from the ingestion buffer 310. Accordingly, theingest manager 406 can track the location of the data in the ingestionbuffer 310 that the ingest manager 406 (for example, a partition manager408) has received from the ingestion buffer 310. In some embodiments,the ingest manager 406 stores the read pointers or location marker inone or more data stores, such as but not limited to, common storage 216,DynamoDB, S3, or another type of storage system, shared storage system,or networked storage system, etc. As the indexing nodes 404 are assignedto process data records, or as an indexing node 404 processes a datarecord, and the markers are updated by the intake system 210, the ingestmanager 406 can be updated to reflect the changes to the read pointersor location markers. In this way, if a partition manager 408 becomesunresponsive or unavailable, the ingest manager 406 can assign adifferent partition manager 408 to manage the data stream without losingcontext of what data is to be read from the intake system 210.Accordingly, in some embodiments, by using the ingestion buffer 310 andtracking the location of the location markers in the shards of theingestion buffer, the indexing system 212 can aid in providing astateless indexing service.

In some embodiments, such as where the ingest manager 406 is implementedas part of an indexing node 404, the ingest manager 406 can beimplemented as a background process, or daemon, in the indexing node 404and the partition managers 408 can be implemented as threads, copies, orforks of the background process. In some cases, an ingest manager 406can copy itself, or fork, to create a partition manager 408 or cause atemplate process to copy itself, or fork, to create each new partitionmanager 408, etc. This may be done for multithreading efficiency or forother reasons related to containerization and efficiency of managingindexers 410. In certain embodiments, the ingest manager 406 generates anew process for each partition manager 408. In some cases, by generatinga new process for each partition manager 408, the ingest manager 406 cansupport multiple language implementations and be language agnostic. Forexample, the ingest manager 406 can generate a process for a partitionmanager 408 in Python and create a second process for a partitionmanager 408 in Golang, etc.

3.3.3. Partition Manager

A partition manager 408 can manage the distribution of the data recordsreceived from one or more partitions or shards of the ingestion buffer310 to the indexing nodes 404. As mentioned, the ingest manager 406 cangenerate or assign one or more partition managers 408 for each partitionor shard, or can assign a single partition manager 408 for more than onepartition or shard. A partition manager 408 can be implemented as adistinct computing device, virtual machine, container, container of apod, or a process or thread associated with a container. In some cases,the partition manager 408 can be implemented as part of the indexingnode 404 (non-limiting example: shown in FIG. 4A), as a sub-component ofthe ingest manager 406 (non-limiting example: shown in FIG. 4B), or as aseparate component of the indexing system 212.

In some cases, managing the distribution of data records can include,but is not limited to, communicating one or more data records, orportions thereof, to an indexing node 404 (for example, to an indexer410) for processing, monitoring the indexing node 404, monitoring thesize of data being processed by the indexing node 404, instructing theindexing node 404 to move the data to common storage 216, or reportingthe storage of the data to the intake system 210.

A partition manager 408 can receive data records from one or morepartition(s) and can distribute the data records to one or more indexingnodes 404. In certain embodiments, such as the embodiment shown in FIG.4A, the partition manager 408 can assign data records to one or moreindexing nodes 404 based on their availability.

In some embodiments, such as the embodiment shown in FIG. 4B, thepartition manager 408 can communicate a data record to an indexing node404 for processing based on a data identifier associated with the datarecord. In certain embodiments, the data records received from apartition of the intake system can be associated with different dataidentifiers (non-limiting examples: tenant identifier, data sourceidentifier, sourcetype identifier, etc.). For example, the data recordsreceived from the ingestion buffer 310 can be associated with differenttenants. In some cases, using the data identifier, the partition manager408 can determine which indexing node 404 is to process a particulardata record. For example, based on a tenant identifier, the partitionmanager 408 can communicate data records associated with the same tenantto the same indexing node 404 (or group of indexing nodes 404).Accordingly, a particular partition manager 408 can process data recordsfrom different tenants, data sources, or with different sourcetypes.

In some embodiments, the partition manager 408 can determine whichindexing node 404 to process the data based on an indexing nodeassignment. In certain embodiments, the partition manager 408 candetermine the indexing node assignment itself or receive the indexingnode assignment from another component of the data intake and querysystem 108 or indexing system 212, such as the resource catalog 420 orresource monitor 418.

In some cases, the partition manager 408 can selectively and dynamicallydistribute data records associated with different tenants to differentindexing nodes 404 for processing. Furthermore, in certain embodiments,the partition manager 408 and/or ingest manager 406 can track whichindexing node 404 is assigned to process which data record. In this way,if an indexing node 404 fails or becomes unresponsive, the partitionmanager 408 can know which data records are to be reassigned to otherindexing nodes 404. In some embodiments, the partition manager 408receives data from a pub-sub messaging system, such as the ingestionbuffer 310. As described herein, the ingestion buffer 310 can have oneor more streams of data and one or more shards or partitions associatedwith each stream of data. Each stream of data can be separated intoshards and/or other partitions or types of organization of data. Incertain cases, each shard can include data from multiple tenants,indexes, etc. For example, one shard can include records from Tenants A,B, and C, and a second shard can include records from Tenants B, C, andD.

In some cases, each shard can correspond to data associated with aparticular tenant, index, source, sourcetype, etc. Accordingly, in someembodiments, the indexing system 212 can include a partition manager 408for individual tenants, indexes, sources, sourcetypes, etc. In somecases, based on the tenant identifier associated with a particular datarecord, the indexing system 212 can manage and process the datadifferently. For example, the indexing system 212 can assign moreindexing nodes 404 to process data from one tenant than another tenant,or store buckets associated with one tenant or index more frequently tocommon storage 216 than buckets associated with a different tenant orindex, etc.

In certain embodiments, each shard can include data associated withmultiple tenants, indexes, sources, or sourcetypes. In some suchembodiments, the partition manager 408 assigned to a particular shardcan concurrently process data associated with multiple tenants, indexes,sources, or sourcetypes.

In some embodiments, a partition manager 408 receives data from one ormore of the shards or partitions of the ingestion buffer 310. Thepartition manager 408 can forward one or more data records from theshards/partitions to indexing nodes 404 for processing. In some cases,the amount or size of the data record(s) coming through a partition mayexceed the partition's (or ingestion buffer's 310) throughput. Forexample, 4 MB/s of data records may be sent to an ingestion buffer 310for a particular partition, but the ingestion buffer 310 may be able toprocess only 2 MB/s of data per partition. Accordingly, in someembodiments, one or more data records can include a reference to alocation in storage where the indexing node 404 can retrieve data. Forexample, a reference pointer to the data to be processed can be placedin the ingestion buffer 310 rather than putting the data to be processeditself into the ingestion buffer 310. The reference pointer canreference a chunk of data or a file that is larger than the throughputof the ingestion buffer 310 for that partition. In this way, the dataintake and query system 108 can increase the throughput of individualpartitions of the ingestion buffer 310. In some embodiments, thepartition manager 408 can obtain the reference pointer from theingestion buffer 310 and retrieve data from the referenced storage forprocessing. In certain embodiments, the partition manager 408 forwardsthe data record with the reference pointer to the indexing node 404 andthe indexing node 404 retrieves the data from the referenced storagelocation. In some cases, the referenced storage to which referencepointers in the ingestion buffer 310 point can correspond to the commonstorage 216 or other shared storage or local storage. In someimplementations, the chunks of data to which the reference pointersrefer may be directed to common storage 216 from intake system 210,e.g., streaming data processor 308 or ingestion buffer 310.

In certain embodiments, as an indexing node 404 processes the datarecord(s), stores the data in buckets, and generates indexes of thedata, the partition manager(s) 408 can monitor the indexing node 404(and/or the indexer(s) 410). For example, a partition manager 408 canmonitor the size of the data on an indexer 410 (inclusive or exclusiveof the data store 412). In some cases, the size of the data on anindexer 410 can correspond to the data that is actually received fromthe particular partition of the intake system 210 (or retrieved usingthe data received from the particular partition), as well as datagenerated by the indexer 410 based on the received data (e.g., invertedindexes, summaries, etc.), and may correspond to one or more buckets.For instance, the indexer 410 may have generated one or more buckets foreach tenant and/or index associated with data being processed in theindexer 410. In some cases, such as when multiple indexers 410 processthe data records from the same index, the aggregated size of the data oneach of those indexers 410 can correspond to the data that is actuallyreceived from the particular partition of the intake system 210, as wellas data generated by the indexers 410 based on the received data.

Based on a bucket roll-over policy, the partition manager 408 caninstruct the indexer(s) 410 to convert editable groups of data orbuckets to non-editable groups or buckets and/or copy the dataassociated with the partition to common storage 216. In someembodiments, the bucket roll-over policy can indicate that the data,which may have been indexed by the indexer(s) 410 and stored in the datastore 412 in various buckets, is to be copied to common storage 216based on a determination that the size of the data satisfies a thresholdsize. In some cases, the bucket roll-over policy can include differentthreshold sizes for different data associated with different dataidentifiers identifying different tenants, data sources, sourcetypes,hosts, users, partitions, partition managers, or the like. In someimplementations, the bucket roll-over policy may be modified by otherfactors, such as an identity of a tenant associated with one or moreindexing nodes 404, system resource usage, which could be based on thepod(s) or other container(s) that contain the indexing node(s) 404, orone of the physical hardware layers with which the indexing node(s) 404are running, or any other appropriate factor for scaling and systemperformance of indexing nodes 404 or any other system component.

In certain embodiments, the bucket roll-over policy can indicate data isto be copied to common storage 216 based on a determination that theamount of data (or a subset thereof) of the indexing node 404 satisfiesa threshold amount. Further, the bucket roll-over policy can indicatethat the one or more partition managers 408 or an indexing node 404 areto communicate with each other or with the ingest manager 406 or theingest manager 406 to monitor the amount of data on the indexer 410assigned to the indexing node 404 and determine that the amount of dataon the indexer 410 (or data store 412) satisfies a threshold amount.Accordingly, based on the bucket roll-over policy, one or more of thepartition managers 408 or the ingest manager 406 or the ingest manager406 can instruct the indexer 410 to convert editable buckets tonon-editable buckets and/or store the data.

In certain embodiments, the bucket roll-over policy can indicate thatbuckets are to be converted to non-editable buckets and stored in commonstorage 216 based on a collective size of buckets satisfying a thresholdsize. In some cases, the bucket roll-over policy can use differentthreshold sizes for conversion and storage. For example, the bucketroll-over policy can use a first threshold size to indicate wheneditable buckets are to be converted to non-editable buckets (e.g., stopwriting to the buckets) and a second threshold size to indicate when thedata (or buckets) are to be stored in common storage 216. In certaincases, the bucket roll-over policy can indicate that the partitionmanager(s) 408 are to send a single command to the indexing node(s) 404or the indexer(s) 410 that causes the indexer(s) 410 to convert editablebuckets to non-editable buckets and store the buckets in common storage216.

The bucket roll-over policy can use other criteria to determine whenbuckets are to be converted and stored to common storage 216. Forexample, the bucket roll-over policy can indicate that buckets are to berolled over at predetermined or dynamic time intervals with or withoutregard to size, etc.

Any one or any combination of the aforementioned bucket roll-overpolicies can be used for different data. In some cases, the indexers 410can use different bucket roll-over policies for buckets associated withdifferent data identifiers. For example, the bucket roll-over policy forbuckets associated with Tenant A can use one threshold for determiningwhen to roll buckets over to common storage and the bucket roll-overpolicy for buckets associated with Tenant B can use a differentthreshold. Accordingly, it will be understood that the indexers 410and/or partition manager 408 can concurrently use/apply different bucketroll-over policies to different buckets.

Based on an acknowledgement that the data associated with a tenant, datasource, sourcetype, host, user, partition, partition manager, or thelike, has been stored in common storage 216, the partition manager 408can communicate to the intake system 210, either directly or through theingest manager 406 that the data has been stored and/or that thelocation marker or read pointer can be moved or updated. In some cases,the partition manager 408 receives the acknowledgement that the data hasbeen stored from common storage 216 and/or from the indexing node 404,such as from the indexer 410. In certain embodiments, which will bedescribed in more detail herein, the intake system 210 does not receivea communication that the data stored in intake system 210 has been readand processed until after that data has been stored in common storage216.

The acknowledgement that the data has been stored in common storage 216can also include location information about the data within the commonstorage 216. For example, the acknowledgement can provide a link, map,or path to the copied data in the common storage 216. Using theinformation about the data stored in common storage 216, the partitionmanager 408 can update the data store catalog 220. For example, thepartition manager 408 can update the data store catalog 220 with anidentifier of the data (e.g., bucket identifier, tenant identifier,partition identifier, etc.), the location of the data in common storage216, a time range associated with the data, etc. In this way, the datastore catalog 220 can be kept up-to-date with the contents of the commonstorage 216.

Moreover, as additional data is received from the intake system 210, thepartition manager 408 can continue to communicate the data to theindexing nodes 404, monitor the size or amount of data on an indexer410, instruct an indexer 410 to copy the data to common storage 216,communicate the successful storage of the data to the intake system 210,and update the data store catalog 220.

As a non-limiting example, consider the scenario in which the intakesystem 210 communicates a plurality of data records from a particularpartition to the indexing system 212. The intake system 210 can trackwhich data it has sent and a location marker for the data in the intakesystem 210 (e.g., a marker that identifies data that has been sent tothe indexing system 212 for processing).

As described herein, the intake system 210 can retain or persistentlymake available the sent data until the intake system 210 receives anacknowledgement from the indexing system 212 that the sent data has beenprocessed, stored in persistent storage (e.g., common storage 216), oris safe to be deleted. In this way, if an indexing node 404, ingestmanager 406, or partition manager 408 assigned to process the sent databecomes unresponsive or is lost, e.g., due to a hardware failure or acrash, the data that was sent to the unresponsive component will not belost. Rather, a different indexing node 404, ingest manager 406, orpartition manager 408, can obtain and process the data from the intakesystem 210.

In some embodiments, as the data records from a partition of the ingestbuffer 310 may be processed by different indexing nodes 404, the intakesystem 210 can retain or persistently make available a data record untilthe intake system 210 receives an acknowledgement from the indexingsystem 212 that the data record and other data records sent prior to thedata record from the same partition have been processed. For example, ifdata records 1-5 are sent (in that order) to a partition manager 408 anddistributed to five indexing nodes 404, the intake system 210 can retaindata record 5 until it receives an acknowledgement that data records 1-4have been processed and relevant data is stored in common storage 216.The intake system 210 can retain data record 5 even if the correspondingindexing node 404 completes its processing of data record 5 before theother indexing nodes 404 complete the processing of data records 1-4.

As the indexing system 212 stores the data in common storage 216, it canreport the storage to the intake system 210. In response, the intakesystem 210 can update its marker to identify different data that hasbeen sent to the indexing system 212 for processing, but has not yetbeen stored. By moving the marker, the intake system 210 can indicatethat the previously-identified data has been stored in common storage216, can be deleted from the intake system 210 or, otherwise, can beallowed to be overwritten, lost, etc. In certain embodiments, theindexing system 212 can report the storage of a particular data recordonce it determines that any records received prior to it from the samepartition have also been stored.

With reference to the example above, in some embodiments, the ingestmanager 406 can track the marker used by the ingestion buffer 310, andthe partition manager 408 can receive data records from the ingestionbuffer 310 and forward one or more data records to an indexing node 404,for example to an indexer 410, for processing (or use the data in theingestion buffer to obtain data from a referenced storage location andforward the obtained data to the indexer). The partition manager 408 canmonitor the amount of data being processed and instruct the indexingnode 404 to copy the data to common storage 216. Once the data is storedin common storage 216, the partition manager 408 can report the storageto the ingestion buffer 310, so that the ingestion buffer 310 can updateits marker. In addition, the ingest manager 406 can update its recordswith the location of the updated marker. In this way, if partitionmanager 408 become unresponsive or fails, the ingest manager 406 canassign a different partition manager 408 to obtain the data from thedata stream without losing the location information, or if the indexer410 becomes unavailable or fails, the ingest manager 406 can assign adifferent indexer 410 to process and store the data.

In some cases, the partition manager 408 dynamically distributes datarecords to different indexing nodes based on an indexing nodeassignment. In some embodiments, the partition manager 408 receives anindexing node assignment from the resource monitor 418, or othercomponent of the data intake and query system 108 to determine whichindexing node 404 to forward a data record. In certain embodiments, thepartition manager 408 can determine the indexing node assignment itself,or include or consult an indexing node assignment listing that storesrecent indexing node assignments. The table or list can be stored as alookup table or in a database, etc.

In certain embodiments, the partition manager 408 can consult theindexing node assignment listing to determine whether a data identifier(non-limiting example: tenant identifier) relating to a particular datarecord to be distributed to an indexing node is already associated witha particular indexing node 404 or group of indexing nodes 404. If it is,the partition manager 408 can communicate the particular data record tothe particular indexing node 404. If it is not, the partition manager408 can determine the indexing node assignment or request one from theresource monitor 418, or other component of the data intake and querysystem 108 to determine which indexing node 404 to forward a datarecord.

In some cases, the indexing node assignment listing can include anindication of the data identifiers associated with data records thathave been assigned to an indexing node 404 over a certain period oftime, such as the last 15, 30, 60, or 90 seconds. In some cases, theindexing node assignment listing is cleared or deleted periodically,such as every 15, 30, 60, or 90 seconds be updated. In this way, theindexing node assignment listing can store the more recent indexing nodeassignments.

In some cases, a different indexing node assignment listing can bestored on or associated with each different partition manager 408. Forexample, a particular partition manager 408 can manage its own indexingnode assignment listing by cataloging the indexing node assignments,which in some embodiments, can be received from the resource catalog420. As another example, the ingest manager 406 can manage some or allof the indexing node assignment listings of the partition managers 408.In some cases, an indexing node assignment listing can be associatedwith some or all of the partition managers 408. For example, the ingestmanager 406 or the partition managers 408 can manage the indexing nodeassignment listing by cataloging the indexing node assignments for allof the partition managers 408 associated with the ingest manager 406.

3.3.4. Indexing Nodes

The indexing nodes 404 can include one or more components to implementvarious functions of the indexing system 212. For example, in theillustrated embodiment of FIG. 4A, the indexing node 404 includes one ormore ingest managers 406, partition managers 408, indexers 410, datastores 412, and/or bucket managers 414. As another example, in theillustrated embodiment of FIG. 4B, the indexing node 404 includes anindexer 410, a data store 412, and a bucket manager 414. As describedherein, the indexing nodes 404 can be implemented on separate computingdevices or as containers or virtual machines in a virtualizationenvironment.

In some embodiments, an indexing node 404, can be implemented as adistinct computing device, virtual machine, container, pod, or a processor thread associated with a container, or using multiple-relatedcontainers. In certain embodiments, such as in a Kubernetes deployment,each indexing node 404 can be implemented as a separate container orpod. For example, one or more of the components of the indexing node 404can be implemented as different containers of a single pod, e.g., on acontainerization platform, such as Docker, the one or more components ofthe indexing node can be implemented as different Docker containersmanaged by synchronization platforms such as Kubernetes or Swarm.Accordingly, reference to a containerized indexing node 404 can refer tothe indexing node 404 as being a single container or as one or morecomponents of the indexing node 404 being implemented as different,related containers or virtual machines.

In certain embodiments, each indexing node 404 can include a monitoringmodule. In some cases, the monitoring modulate can communicate one ormore of an indexing node identifier, metrics, status identifiers,network architecture data, or indexing node assignments to the resourcemonitor 418. For example, as described herein, the monitoring module canindicate a utilization rate of an indexing node 404, an amount ofprocessing resources in use by an indexing node 404, an amount of memoryused by an indexing node 404, an availability or responsiveness of anindexing node 404, etc.

3.3.4.1. Indexer and Data Store

As described herein, the indexer 410 can be the primary indexingexecution engine, and can be implemented as a distinct computing device,container, container within a pod, etc. For example, the indexer(s) 410can be tasked with parsing, processing, indexing, and storing the datareceived from the intake system 210 via the partition manager(s) 408.Specifically, in some embodiments, the indexer 410 can parse theincoming data to identify timestamps, generate events from the incomingdata, group and save events into buckets, generate summaries or indexes(e.g., time series index, inverted index, keyword index, etc.) of theevents in the buckets, and store the buckets in common storage 216.

As used herein, an index can refer to different data structures. In somecases, index can refer to a logical division of data similar to apartition. In certain cases, index can refer to a data structure, suchas a file, that stores information about other data (non-limitingexamples: a time series index, inverted index, keyword index). Inaddition, when used as a verb, index can refer to the processing and/orstoring of data by the indexing system 212 and/or intake system 210. Forexample, in some cases, the indexing system 212 can index dataassociated with a particular index (non-limiting example: main index) togenerate events and one or more indexes that include information aboutthe generated events (non-limiting example: time series index). As partof the indexing, the generated events and indexes can be stored as partof or in association with the particular index. In some cases, oneindexer 410 can be assigned to each partition manager 408 such that thesingle indexer 410 processes some or all of the data from its assignedpartition manager 408. In certain embodiments, one indexer 410 canreceive and process the data from multiple partition managers 408 in theindexing system. For example, with reference to FIG. 4A, one indexer 410can receive and process the data from partition managers 408 on the sameindexing node 404, on multiple indexing nodes 404, on the same ingestmanager 406, or multiple ingest managers 406. As another example, withreference to FIG. 4B, an indexer 410 can receive and process data frommultiple partition managers 408 and/or ingest managers 406. In somecases, multiple indexing nodes 404 or indexers 410 can be assigned to asingle partition manager 408. In certain embodiments, the multipleindexing nodes 404 or indexers 410 can receive and process the datareceived from the single partition manager 408, as well as data fromother partition managers 408.

In some embodiments, the indexer 410 can store the events and buckets inthe data store 412 according to a bucket creation policy. The bucketcreation policy can indicate how many buckets the indexer 410 is togenerate for the data that it processes. In some cases, based on thebucket creation policy, the indexer 410 generates at least one bucketfor each unique combination of a tenant and index (which may also bereferred to as a partition) associated with the data that it processes.For example, if the indexer 410 receives data associated with threetenants A, B, C, then the indexer 410 can generate at least threebuckets: at least one bucket for each of Tenant A, Tenant B, and TenantC. As another example, if the indexer 410 receives data associated withindex A of Tenant A from one partition or shard, and receives dataassociated with index A of Tenant A and index B of Tenant B from asecond partition or shard, then the indexer 410 can generate at leasttwo buckets: at least one bucket for Tenant A (including datacorresponding to index A from partition 1 and partition 2) and Tenant B(including data corresponding to index B from partition 2).

In some cases, based on the bucket creation policy, the indexer 410generates at least one bucket for each combination of tenant and indexassociated with the data that it processes. For example, if the indexer410 receives data associated with three tenants A, B, C, each with twoindexes X, Y, then the indexer 410 can generate at least six buckets: atleast one bucket for each of Tenant A::Index X, Tenant A::Index Y,Tenant B::Index X, Tenant B::Index Y, Tenant C::Index X, and TenantC::Index Y. Additional buckets may be generated for a tenant/index pairbased on the amount of data received that is associated with thetenant/partition pair. It will be understood that the indexer 410 cangenerate buckets using a variety of policies. For example, the indexer410 can generate one or more buckets for each tenant, partition, source,sourcetype, etc.

In some cases, if the indexer 410 receives data that it determines to be“old,” e.g., based on a timestamp of the data or other temporaldetermination regarding the data, then it can generate a bucket for the“old” data. In some embodiments, the indexer 410 can determine that datais “old,” if the data is associated with a timestamp that is earlier intime by a threshold amount than timestamps of other data in thecorresponding bucket (e.g., depending on the bucket creation policy,data from the same partition and/or tenant) being processed by theindexer 410. For example, if the indexer 410 is processing data for thebucket for Tenant A::Index X having timestamps on 4/23 between 16:23:56and 16:46:32 and receives data for the Tenant A::Index X bucket having atimestamp on 4/22 or on 4/23 at 08:05:32, then it can determine that thedata with the earlier timestamps is “old” data and generate a new bucketfor that data. In this way, the indexer 410 can avoid placing data inthe same bucket that creates a time range that is significantly largerthan the time range of other buckets, which can decrease the performanceof the system as the bucket could be identified as relevant for a searchmore often than it otherwise would.

The threshold amount of time used to determine if received data is“old,” can be predetermined or dynamically determined based on a numberof factors, such as, but not limited to, time ranges of other buckets,amount of data being processed, timestamps of the data being processed,etc. For example, the indexer 410 can determine an average time range ofbuckets that it processes for different tenants and indexes. If incomingdata would cause the time range of a bucket to be significantly larger(e.g., 25%, 50%, 75%, double, or other amount) than the average timerange, then the indexer 410 can determine that the data is “old” data,and generate a separate bucket for it. By placing the “old” bucket in aseparate bucket, the indexer 410 can reduce the instances in which thebucket is identified as storing data that may be relevant to a query.For example, by having a smaller time range, the query system 214 mayidentify the bucket less frequently as a relevant bucket then if thebucket had the large time range due to the “old” data. Additionally, ina process that will be described in more detail herein, time-restrictedsearches and search queries may be executed more quickly because theremay be fewer buckets to search for a particular time range. In thismanner, computational efficiency of searching large amounts of data canbe improved. Although described with respect detecting “old” data, theindexer 410 can use similar techniques to determine that “new” datashould be placed in a new bucket or that a time gap between data in abucket and “new” data is larger than a threshold amount such that the“new” data should be stored in a separate bucket.

In some cases, based on a bucket roll-over policy, the indexer 410periodically determines to convert editable groups of data or buckets tonon-editable groups or buckets and/or copy the data associated with thepartition or tenant identifier to common storage 216. For example, thebucket roll-over policy may indicate a time-based schedule so that theindexer 410 determines to copy and/or store the data every X number ofseconds, or every X minute(s), and so forth.

In some embodiments, the bucket roll-over policy can indicate that thedata, which may have been indexed by the indexer(s) 410 and stored inthe data store 412 in various buckets, is to be copied to common storage216 based on a determination that the size of the data satisfies athreshold size. In some cases, the bucket roll-over policy can includedifferent threshold sizes for different data associated with differentdata identifiers identifying different tenants, data sources,sourcetypes, hosts, users, partitions, partition managers, or the like.The threshold amount can correspond to the amount of data beingprocessed by the indexer 410 for any partition or any tenant identifier.

In some cases, the bucket roll-over policy may indicate that one or morebuckets are to be rolled over based on a combination of a time-basedschedule and size. For example, the bucket roll-over policy may indicatea time-based schedule in combination with a data threshold. For example,the indexer 410 can determine to copy the data to common storage 216based on a determination that the amount of data stored on the indexer410 satisfies a threshold amount or a determination that the data hasnot been copied in X number of seconds, X number of minutes, etc.Accordingly, in some embodiments, the indexer 410 can determine that thedata is to be copied to common storage 216 without communication withthe partition manager 408 or the ingest manager 416. In someimplementations, the bucket roll-over policy may be modified by otherfactors, such as an identity of a tenant associated with one or moreindexing nodes 404, system resource usage, which could be based on thepod(s) or other container(s) that contain the indexing node(s) 404, orone of the physical hardware layers with which the indexing node(s) 404are running, or any other appropriate factor for scaling and systemperformance of indexing nodes 404 or any other system component.

In certain embodiments, the partition manager 408 can instruct theindexer 410 to copy the data to common storage 216 based on a bucketroll-over policy. For example, the partition manager 408 can monitor thesize of the buckets and instruct the indexer 410 to copy the bucket tocommon storage 216. The threshold size can be predetermined ordynamically determined.

In certain embodiments, the partition manager 408 can monitor the sizeof multiple, or all, buckets associated with the indexes, indexingnode(s) 404, or indexer(s) 410 being managed by the partition manager408, and based on the collective size of the buckets satisfying athreshold size, instruct the indexer 410 to copy the buckets associatedwith the index to common storage 216. In certain cases, one or morepartition managers 408, or ingest managers 406 can monitor the size ofbuckets across multiple, or all indexes, associated with one or moreindexing nodes 404, and instruct the indexer(s) 410 to copy the bucketsto common storage 216 based on the size of the buckets satisfying athreshold size.

As described herein, buckets in the data store 412 that are being editedby an indexer 410 can be referred to as hot buckets or editable buckets.For example, an indexer 410 can add data, events, and indexes toeditable buckets in the data store 412, etc. Buckets in the data store412 that are no longer edited by an indexer 410 can be referred to aswarm buckets or non-editable buckets. In some embodiments, once anindexer 410 determines that a hot bucket is to be copied to commonstorage 216, it can convert the hot (editable) bucket to a warm(non-editable) bucket, and then move or copy the warm bucket to thecommon storage 216 based on a bucket roll-over policy. Once the warmbucket is moved or copied to common storage 216, an indexer 410 cannotify a partition manager 408 that the data associated with the warmbucket has been processed and stored. As mentioned, a partition manager408 can relay the information to the intake system 210. In addition, anindexer 410 can provide a partition manager 408 with information aboutthe buckets stored in common storage 216, such as, but not limited to,location information, tenant identifier, index identifier, time range,etc. As described herein, a partition manager 408 can use thisinformation to update the data store catalog 220. In certainembodiments, the indexer 410 can update the data store catalog 220. Forexample, the indexer 410 can update the data store catalog 220 based onthe information it receives from the common storage 216 about the storedbuckets.

3.3.4.2. Bucket Manager

The bucket manager 414 can manage the buckets stored in the data store412, and can be implemented as a distinct computing device, virtualmachine, container, container of a pod, or a process or threadassociated with a container. In some cases, the bucket manager 414 canbe implemented as part of the indexer 410, indexing node 404, the ingestmanager 406, or as a separate component of the indexing system 212.

As described herein, the indexer 410 stores data in the data store 412as one or more buckets associated with different tenants, indexes, etc.In some cases, the contents of the buckets are not searchable by thequery system 214 until they are stored in common storage 216. Forexample, the query system 214 may be unable to identify data responsiveto a query that is located in hot (editable) buckets in the data store412 and/or the warm (non-editable) buckets in the data store 412 thathave not been copied to common storage 216. Thus, query results may beincomplete or inaccurate, or slowed as the data in the buckets of thedata store 412 are copied to common storage 216.

To decrease the delay between processing and/or indexing the data andmaking that data searchable, the indexing system 212 can use a bucketroll-over policy to determine when to convert hot buckets to warmbuckets more frequently (or convert based on a smaller threshold size)and/or copy the warm buckets to common storage 216. While converting hotbuckets to warm buckets more frequently or based on a smaller storagesize can decrease the lag between processing the data and making itsearchable, it can increase the storage size and overhead of buckets incommon storage 216. For example, each bucket may have overheadassociated with it, in terms of storage space required, processor powerrequired, or other resource requirement. Thus, more buckets in commonstorage 216 can result in more storage used for overhead than forstoring data, which can lead to increased storage size and costs. Inaddition, a larger number of buckets in common storage 216 can increasequery times, as the opening of each bucket as part of a query can havecertain processing overhead or time delay associated with it.

To decrease search times and reduce overhead and storage associated withthe buckets (while maintaining a reduced delay between processing thedata and making it searchable), the bucket manager 414 can monitor thebuckets stored in the data store 412 and/or common storage 216 and mergebuckets according to a bucket merge policy. For example, the bucketmanager 414 can monitor and merge warm buckets stored in the data store412 before, after, or concurrently with the indexer copying warm bucketsto common storage 216.

The bucket merge policy can indicate which buckets are candidates for amerge or which bucket to merge (e.g., based on time ranges, size,tenant, index, or other identifiers), the number of buckets to merge,size or time range parameters for the merged buckets, and/or a frequencyfor creating the merged buckets. For example, the bucket merge policycan indicate that a certain number of buckets are to be merged,regardless of size of the buckets. As another non-limiting example, thebucket merge policy can indicate that multiple buckets are to be mergeduntil a threshold bucket size is reached (e.g., 750 MB, or 1 GB, ormore). As yet another non-limiting example, the bucket merge policy canindicate that buckets having a time range within a set period of time(e.g., 30 sec, 1 min., etc.) are to be merged, regardless of the numberor size of the buckets being merged.

In addition, the bucket merge policy can indicate which buckets are tobe merged or include additional criteria for merging buckets. Forexample, the bucket merge policy can indicate that only buckets havingthe same tenant identifier and/or index are to be merged, or setconstraints on the size of the time range for a merged bucket (e.g., thetime range of the merged bucket is not to exceed an average time rangeof buckets associated with the same source, tenant, partition, etc.). Incertain embodiments, the bucket merge policy can indicate that bucketsthat are older than a threshold amount (e.g., one hour, one day, etc.)are candidates for a merge or that a bucket merge is to take place oncean hour, once a day, etc. In certain embodiments, the bucket mergepolicy can indicate that buckets are to be merged based on adetermination that the number or size of warm buckets in the data store412 of the indexing node 404 satisfies a threshold number or size, orthe number or size of warm buckets associated with the same tenantidentifier and/or partition satisfies the threshold number or size. Itwill be understood, that the bucket manager 414 can use any one or anycombination of the aforementioned or other criteria for the bucket mergepolicy to determine when, how, and which buckets to merge.

Once a group of buckets is merged into one or more merged buckets, thebucket manager 414 can copy or instruct the indexer 410 to copy themerged buckets to common storage 216. Based on a determination that themerged buckets are successfully copied to the common storage 216, thebucket manager 414 can delete the merged buckets and the buckets used togenerate the merged buckets (also referred to herein as unmerged bucketsor pre-merged buckets) from the data store 412 according to a bucketmanagement policy.

In some cases, the bucket manager 414 can also remove or instruct thecommon storage 216 to remove corresponding pre-merged buckets from thecommon storage 216 according to the bucket management policy. The bucketmanagement policy can indicate when the pre-merged buckets are to bedeleted or designated as able to be overwritten from common storage 216and/or in the data store 412.

In some cases, the bucket management policy can indicate that thepre-merged buckets are to be deleted immediately, once any queriesrelying on the pre-merged buckets are completed, after a predeterminedamount of time, etc. Further, the bucket management policy can indicatedifferent criteria for deleting data from common storage 216 and/or thedata store 412.

In some cases, the pre-merged buckets may be in use or identified foruse by one or more queries. Removing the pre-merged buckets from commonstorage 216 in the middle of a query may cause one or more failures inthe query system 214 or result in query responses that are incomplete orerroneous. Accordingly, the bucket management policy, in some cases, canindicate to the common storage 216 that queries that arrive before amerged bucket is stored in common storage 216 are to use thecorresponding pre-merged buckets and queries that arrive after themerged bucket is stored in common storage 216 are to use the mergedbucket.

Further, the bucket management policy can indicate that once queriesusing the pre-merged buckets are completed, the buckets are to beremoved from common storage 216. However, it will be understood that thebucket management policy can indicate removal of the buckets in avariety of ways. For example, per the bucket management policy, thecommon storage 216 can remove the buckets after on one or more hours,one day, one week, etc., with or without regard to queries that may berelying on the pre-merged buckets. In some embodiments, the bucketmanagement policy can indicate that the pre-merged buckets are to beremoved without regard to queries relying on the pre-merged buckets andthat any queries relying on the pre-merged buckets are to be redirectedto the merged bucket. It will be understood that the bucket manager 414can use different bucket management policies for data associated withdifferent data identifiers. For example, the bucket manager 414 can useone bucket management policy for data associated with a first tenant anduse another bucket management policy for data associated with a secondtenant. In this way, the bucket manager can concurrently use differentbucket management policies for different data.

In addition to removing the pre-merged buckets and merged bucket fromthe data store 412 and removing or instructing common storage 216 toremove the pre-merged buckets from the data store(s) 218, the bucketmanager 414 can update the data store catalog 220 or cause the indexer410 or partition manager 408 to update the data store catalog 220 withthe relevant changes. These changes can include removing reference tothe pre-merged buckets in the data store catalog 220 and/or addinginformation about the merged bucket, including, but not limited to, abucket, tenant, and/or partition identifier associated with the mergedbucket, a time range of the merged bucket, location information of themerged bucket in common storage 216, etc. In this way, the data storecatalog 220 can be kept up-to-date with the contents of the commonstorage 216.

3.3.5. Resource Catalog

The resource catalog 420 can store information relating to the indexingnodes 404 of the indexing system 212, such as, but not limited to,indexing node identifiers, metrics, status identifiers, networkarchitecture data, or indexing node assignments. The resource catalog420 can be maintained (for example, populated, updated, etc.) by theresource monitor 418. As mentioned, in some embodiments, the resourcemonitor 418 and resource catalog 420 can be separate or independent ofthe indexing system 212.

In some cases, the resource catalog 420 includes one or more indexingnode identifiers. As mentioned, the indexing system 212 can include aplurality of indexing nodes 404. In some cases, the resource catalog 420can include a different indexing node identifier for each indexing node404 of the indexing system 212. In some cases, for example if theresource monitor 418 or the indexing system manager 402 generates a newindexing node 404, the resource monitor 418 can update the resourcecatalog 420 to include an indexing node identifier associated with thenew indexing node 404. In some cases, for example, if an indexing node404 is removed from the indexing system 212 or the indexing node 404becomes unresponsive or unavailable, the resource monitor 418 can updatethe resource catalog 420 to remove an indexing node identifierassociated with that indexing node 404. In this way, the resourcecatalog 420 can include up-to-date information relating to whichindexing nodes 404 are instantiated in the indexing system 212.

In some cases, the resource catalog 420 includes one or more metricsassociated with one or more of the indexing nodes 404 in the indexingsystem 212. For example, the metrics can include, but are not limitedto, one or more performance metrics such as CPU-related performancemetrics, memory-related performance metrics, availability performancemetrics, or the like. For example, the resource catalog 420 can includeinformation relating to a utilization rate of an indexing node 404, suchas an indication of which indexing nodes 404, if any, are working atmaximum capacity or at a utilization rate that satisfies utilizationthreshold, such that the indexing node 404 should not be used to processadditional data for a time. As another example, the resource catalog 420can include information relating to an availability or responsiveness ofan indexing node 404, an amount of processing resources in use by anindexing node 404, or an amount of memory used by an indexing node 404.

In some cases, the information relating to the indexing nodes 404includes one or more status identifiers associated with one or more ofthe indexing nodes 404 in the indexing system 212. For example, in somecases, a status identifier associated with one or more of the indexingnodes 404 can include information relating to an availability of anindexing node. For example, the information relating to the indexingnodes 404 can include an indication of whether an indexing node 404 isavailable or unavailable. In some instances, as described herein, thisindication of availability can be based on a status update (or absenceof a status update) from the indexing node 404. In some instances, anindexing node 404 is considered available if it is instantiated in theindexing system 212, provides periodic status updates to the resourcemonitor 418, and/or is responsive communications from the resourcemonitor 418. In some cases, an indexing node 404 is considered availableif one or more metrics associated with the indexing node 404 satisfies ametrics threshold. For example, an indexing node 404 can consideredavailable if a utilization rate of the indexing node 404 satisfies autilization rate threshold. As another example, an indexing node 404 canconsidered available if an amount of memory used by or available to theindexing node 404 satisfies a memory threshold (non-limiting example:available memory >10% of total memory, etc.). As another example, anindexing node 404 can be considered available if an amount of availableprocessing resources of the indexing node 404 satisfies a processingresources threshold (non-limiting example: CPU usage <90% of capacity,etc.) Similarly, in some cases, an indexing node 404 can be consideredunavailable if one or more, or some or all, metrics associated with theindexing node 404 do not satisfy a metrics threshold.

In some cases, the information relating to the indexing nodes 404includes information relating to a network architecture associated withone or more of the indexing nodes 404 in the indexing system 212. Forexample, information relating to a network architecture can include anindication of when, where, or on what host machine, an indexing node isinstantiated. As another example, information relating to a networkarchitecture can include an indication of a location of an indexing node404, for example with reference to other indexing nodes 404. As anotherexample, information relating to a network architecture can include anindication of computing resources shared with other indexing nodes 404,such as data stores, processors, I/O, etc.

In some cases, the information relating to the indexing nodes 404includes information relating to one or more indexing node assignments.As described herein, an indexing node assignment can include anindication of a mapping between a particular indexing node 404 and anidentifier (for example, a tenant identifier, a partition manageridentifier, etc.) or between a particular node and a data recordreceived from the intake system 210. In this way, an indexing nodeassignment can be utilized to determine to which indexing node 404 apartition manager 408 should send data to process. For example, anindexing node assignment can indicate that a particular partitionmanager 408 should send its data to one or more particular indexingnodes 404. As another example, an indexing node assignment can indicatethat some or all data associated with a particular identifier (forexample, data associated with a particular tenant identifier) should beforwarded to one or more a particular indexing node 404 for processing.In some cases, a processing device associated with the resource catalog420 can determine an indexing node assignment and can store the indexingnode assignment in the resource catalog 420. In some cases, an indexingnode assignment, is not stored in the resource catalog 420. For example,each time the resource monitor 418 receives a request for an indexingnode assignment from a partition manager 408, the resource monitor 418can use information stored in the resource catalog 420 to determine theindexing node assignment, but the indexing node assignment may not bestored in the resource catalog 420. In this way, the indexing nodeassignments can be altered, for example if necessary based oninformation relating to the indexing nodes 404.

3.3.6. Resource Monitor

The resource monitor 418 can monitor indexing nodes 404, populate andmaintain the resource catalog 420 with relevant information, receiverequests for indexing node 404 availability or assignments, identifyindexing nodes 404 that are available to process data, and/orcommunicate information relating to available indexing nodes (orindexing node assignments). The resource monitor 418 can be implementedas a distinct computing device, virtual machine, container, container ofa pod, or a process or thread associated with a container.

The resource monitor 418 maintains the resource catalog 420. Forexample, the resource monitor 418 can communicate with or monitor theindexing nodes 404 to determine or identify information relating to theindexing nodes 404, such as indexing node identifiers, metrics, statusidentifiers, network architecture data, or indexing node assignments,that it can used to build or update the resource catalog 420. Theresource monitor 418 can populate the resource catalog 420 and/or updateit over time. For example, as information relating to the indexing nodes404 changes for the different indexing nodes 404, the resource monitor418 can update the resource catalog 420. In this way, the resourcecatalog 420 can retain an up-to-date database of indexing nodeinformation.

In some cases, the resource monitor 418 can maintain the resourcecatalog 420 by pinging the indexing nodes 404 for information orpassively receiving it based on the indexing nodes 404 independentlyreporting the information. For instance, the resource monitor 418 canping or receive information from the indexing nodes 404 at predeterminedintervals of time, such as every 1, 2, 5, 10, 30, or 60 seconds. Inaddition or alternatively, the indexing nodes 404 can be configured toautomatically send their data to the resource monitor 418 and/or theresource monitor 418 can ping a particular indexing node 404 after thepassage of a predetermined period of time (for example, 1, 2, 5, 10, 30,or 60 seconds) since the resource monitor 418 requested and/or receiveddata from that particular indexing node 404. In some cases, the resourcemonitor 418 can determine that an indexing node 404 is unavailable orfailing based on the communications or absence of communications fromthe indexing node 404, and can update the resource catalog 420accordingly.

The resource monitor 418 can identify available indexing nodes 404 andprovide indexing node assignments for processing data records. In someembodiments, the resource monitor 418 can respond to requests frompartition managers 408 for an indexing node to process one or more datarecords. As described herein, a partition manager 408 can receive datarecords from the ingestion buffer 310. For each data record (or for agroup of data records), the partition manager 408 can request theresource monitor 418 for an indexing node 404 to process a particulardata record or group of data records, such as data records from the sametenant. In some cases, the resource monitor can respond with an indexingnode identifier that identifies an available indexing node for thepartition manager 408 to send the data. In certain cases, the requestcan include a data identifier associated with the data to be processed,such as a tenant identifier. The resource monitor 418 can use the dataidentifier to determine which indexing node 404 is to process the data.

The resource monitor 418 can identify available indexing nodes using oneor more of various techniques. For example, in some cases, the resourcemonitor 418 identifies an available indexing node 404 based on data inthe resource catalog 420 such as, but not limited to, indexing nodeidentifiers, metrics, status identifiers, network architecture data, orindexing node assignments. In some cases, the resource monitor 418 candetermine that an indexing node 404 is available if data relating tothat indexing node satisfies a certain threshold. For example, theresource monitor 418 can determine that an indexing node 404 isavailable if it is instantiated in the indexing system 212, has recentlyreported data to the resource monitor 418, and/or is responsive tocommunications from the resource monitor 418.

In some cases, the resource monitor 418 can determine that an indexingnode 404 is available if one or more metrics associated with theindexing node 404 satisfies a metrics threshold. For example, theresource monitor 418 can determine that an indexing node 404 isavailable if a utilization rate of the indexing node 404 satisfies autilization rate threshold and/or if an amount of available memoryavailable to the indexing node 404 satisfies a memory threshold. Asanother example, the resource monitor 418 can determine that an indexingnode 404 is available if an amount of available processing resources ofthe indexing node 404 satisfies a processing resources threshold.Similarly, in some cases, an indexing node 404 can be consideredunavailable if one or more, or some or all, metrics associated with theindexing node 404 do not satisfy a metrics threshold.

In addition to identifying available indexing nodes 404, the resourcemonitor 418 can identify to which indexing node a particular data recordor group of records is to be sent. The resource monitor 418 can map orassign a data record to an indexing node to using one or moretechniques. In some embodiments, the resource monitor 418 can use anindexing node mapping policy to determine how to map, link, or associatean indexing node to a data record.

In some embodiments, the indexing node mapping policy can indicate thatdata records are to be assigned to indexing nodes randomly, based on anorder (e.g., sequentially assign indexing nodes 404 as requests arereceived), based on previous assignments, based on a data identifierassociated with the data records, etc.

As described herein, each data record transmitted by the ingestionbuffer 310 can be associated with a data identifier that, for example,relates to a particular data source 202, tenant, index, or sourcetype.In some cases, the resource monitor 418 can use the data identifierassociated with the data record to assign the data record to aparticular indexing node 404. In the event, a partition manager 408receives other data records associated with the same data identifier, itcan communicate the other data records to the same indexing node 404 forprocessing.

In some embodiments, the resource catalog 420 can store an indexing nodeassignment listing that associates indexing nodes 404 with dataidentifiers. In some such embodiments, the indexing node mapping policycan indicate that the resource monitor 418 is to use the listing todetermine whether a particular data identifier is associated with anindexing node 404. As a non-limiting example, if the resource monitor418 receives a request from a partition manager 408 to map a data recordassociated with a data identifier to an indexing node, the resourcemonitor 418 can use the indexing node assignment listing to identify theindexing node that is to process the data record. In some suchembodiments, the indexing node assignment listing can include multipleindexing nodes 404 associated with the data identifier and the resourcemonitor 418 can assign one of the indexing nodes 404 based on itsdetermined availability (non-limiting example: metrics relating to thatindexing node 404 satisfy one or more metrics thresholds). Accordingly,based on the data identifier and the determined availability of theindexing nodes, the resource monitor 418 can assign an indexing node 404to process the data record.

As described herein, in some cases, partition managers 408 can alsostore an indexing node assignment listing. In certain embodiments, theindexing node assignment listing stored by the partition managers 408can be the same as the indexing node assignment listing stored by theresource catalog 420. For example, the resource monitor 418 can generatethe indexing node assignment listing for the resource catalog 420 anddistribute the indexing node assignment listing to the instantiatedpartition managers 408. In some embodiments, the indexing nodeassignment listing stored by the partition managers 408 can be differentfrom the indexing node assignment listing stored by the resource catalog420. For example, the indexing node assignment listing stored by theresource catalog 420 can correspond to indexing node assignments acrosssome or all partition managers 408, whereas the indexing node assignmentlisting for a particular partition manager 408 may only include theindexing node assignments for data that it (or a group of relatedpartition managers 408) has processed.

As another example, in some embodiments, the indexing node mappingpolicy can indicate that the resource monitor 418 is to use a hashfunction or other function to map a data identifier (or data record) toa particular indexing node 404. In certain embodiments, the resourcemonitor 418 can hash the data identifier, and use the output of the hashto identify an available indexing node 404. For example, if there arethree indexing nodes, the resource monitor 418 can assign the datarecord to one of the indexing nodes 404 based on a hash of a tenantidentifier of the data. In this way, other data associated with the sametenant can be assigned to the same indexing nodes 404.

In certain embodiments, the indexing node mapping policy can indicatethat the resource monitor 418 is to use a consistent hash to map thedata identifier to an indexing node 404. As part of using a consistenthash, the resource monitor 418 can perform a hash on identifiers of theindexing nodes and map the hash values to a ring. The resource monitor418 can then perform a hash on the data identifier (non-limitingexample: tenant identifier). Based on the location of the resulting hashvalue on the ring, the resource monitor 418 can assign the data recordto an indexing node. In certain cases, the resource monitor 418 canassign the data record based on the location of the hashed dataidentifier to the location of the hashed indexing node identifiers onthe ring. For example, the resource monitor 418 can map the dataidentifier to the indexing node 404 whose hashed node identifier isclosest to or next in line (in a particular direction) on the hash ringto the hashed data identifier. In some cases, the resource monitor 418maps the data identifier to multiple indexing nodes 404, for example, byselecting two or more indexing nodes that have a position on the hashring that is closest, or next in line, to the hash value of the dataidentifier when fitted on the hash ring. In some cases, the consistenthash function can be configured such that even with a different numberof indexing nodes 404 being instantiated in the indexing system 212, theoutput of the hashing will consistently identify the same indexing node404, or have an increased probability of identifying the same indexingnode 404.

In some instances, the indexing node mapping policy can indicate thatthe resource monitor 418 is to map a data identifier to an indexing node404 randomly, or in a simple sequence (e.g., a first indexing nodes 404is mapped to a first data identifier, a second indexing node 404 ismapped to a second data identifier, etc.). In other instances, asdiscussed, the indexing node mapping policy can indicate that theresource monitor 418 is to map data identifiers to indexing nodes 404based on previous mappings.

In certain embodiments, according to the indexing node mapping policy,indexing nodes 404 may be mapped to data identifiers based on overlapsof computing resources of the indexing nodes 404. For example, if apartition manager 408 is instantiated on the same host system as anindexing node 404, the resource monitor 418 can assign the data from thepartition manager to the indexing node 404.

Accordingly, it will be understood that the resource monitor 418 can mapany indexing node 404 to any data identifier, and that the indexing nodemapping policy can indicate that the resource monitor 418 is to use anyone or any combination of the above-described mechanisms to map dataidentifiers (or data records) to indexing nodes 404.

Based on the determined mapping of a data identifier to an indexing node404, the resource monitor 418 can respond to a partition manager 408.The response can include an identifier for the assigned indexing nodethat is to process the data record or the data records associated with aparticular data identifier. In certain embodiments, the response caninclude instructions that the identified indexing node 404 is to be usedfor a particular length of time, such as one minute, five minutes, etc.

3.4. Query System

FIG. 5 is a block diagram illustrating an embodiment of a query system214 of the data intake and query system 108. The query system 214 canreceive, process, and execute queries from multiple client devices 204,which may be associated with different tenants, users, etc. Similarly,the query system 214 can execute the queries on data from the intakesystem 210, indexing system 212, common storage 216, acceleration datastore 222, or other system. Moreover, the query system 214 can includevarious components that enable it to provide a stateless or state-freesearch service, or search service that is able to rapidly recoverwithout data loss if one or more components of the query system 214become unresponsive or unavailable.

In the illustrated embodiment, the query system 214 includes one or morequery system managers 502 (collectively or individually referred to asquery system manager 502), one or more search heads 504 (collectively orindividually referred to as search head 504 or search heads 504), one ormore search nodes 506 (collectively or individually referred to assearch node 506 or search nodes 506), a resource monitor 508, and aresource catalog 510. However, it will be understood that the querysystem 214 can include fewer or more components as desired. For example,in some embodiments, the common storage 216, data store catalog 220, orquery acceleration data store 222 can form part of the query system 214,etc.

As described herein, each of the components of the query system 214 canbe implemented using one or more computing devices as distinct computingdevices or as one or more container instances or virtual machines acrossone or more computing devices. For example, in some embodiments, thequery system manager 502, search heads 504, and search nodes 506 can beimplemented as distinct computing devices with separate hardware,memory, and processors. In certain embodiments, the query system manager502, search heads 504, and search nodes 506 can be implemented on thesame or across different computing devices as distinct containerinstances, with each container having access to a subset of theresources of a host computing device (e.g., a subset of the memory orprocessing time of the processors of the host computing device), butsharing a similar operating system. In some cases, the components can beimplemented as distinct virtual machines across one or more computingdevices, where each virtual machine can have its own unshared operatingsystem but shares the underlying hardware with other virtual machines onthe same host computing device.

3.4.1. Query System Manager

As mentioned, the query system manager 502 can monitor and manage thesearch heads 504 and search nodes 506, and can be implemented as adistinct computing device, virtual machine, container, container of apod, or a process or thread associated with a container. For example,the query system manager 502 can determine which search head 504 is tohandle an incoming query or determine whether to generate an additionalsearch node 506 based on the number of queries received by the querysystem 214 or based on another search node 506 becoming unavailable orunresponsive. Similarly, the query system manager 502 can determine thatadditional search heads 504 should be generated to handle an influx ofqueries or that some search heads 504 can be de-allocated or terminatedbased on a reduction in the number of queries received.

In certain embodiments, the query system 214 can include one querysystem manager 502 to manage all search heads 504 and search nodes 506of the query system 214. In some embodiments, the query system 214 caninclude multiple query system managers 502. For example, a query systemmanager 502 can be instantiated for each computing device (or group ofcomputing devices) configured as a host computing device for multiplesearch heads 504 and/or search nodes 506.

Moreover, the query system manager 502 can handle resource management,creation, assignment, or destruction of search heads 504 and/or searchnodes 506, high availability, load balancing, applicationupgrades/rollbacks, logging and monitoring, storage, networking, servicediscovery, and performance and scalability, and otherwise handlecontainerization management of the containers of the query system 214.In certain embodiments, the query system manager 502 can be implementedusing Kubernetes or Swarm. For example, in certain embodiments, thequery system manager 502 may be part of a sidecar or sidecar containerthat allows communication between various search nodes 506, varioussearch heads 504, and/or combinations thereof.

In some cases, the query system manager 502 can monitor the availableresources of a host computing device and/or request additional resourcesin a shared resource environment, based on workload of the search heads504 and/or search nodes 506 or create, destroy, or reassign search heads504 and/or search nodes 506 based on workload. Further, the query systemmanager 502 system can assign search heads 504 to handle incomingqueries and/or assign search nodes 506 to handle query processing basedon workload, system resources, etc. In some embodiments, the querysystem manager 502 system can assign search heads 504 to handle incomingqueries based on a search head mapping policy, as described herein.

3.4.2. Search Head

As described herein, the search heads 504 can manage the execution ofqueries received by the query system 214. For example, the search heads504 can parse the queries to identify the set of data to be processedand the manner of processing the set of data, identify the location ofthe data (non-limiting examples: intake system 210, common storage 216,acceleration data store 222, etc.), identify tasks to be performed bythe search head and tasks to be performed by the search nodes 506,distribute the query (or sub-queries corresponding to the query) to thesearch nodes 506, apply extraction rules to the set of data to beprocessed, aggregate search results from the search nodes 506, store thesearch results in the query acceleration data store 222, return searchresults to the client device 204, etc.

As described herein, the search heads 504 can be implemented on separatecomputing devices or as containers or virtual machines in avirtualization environment. In some embodiments, the search heads 504may be implemented using multiple-related containers. In certainembodiments, such as in a Kubernetes deployment, each search head 504can be implemented as a separate container or pod. For example, one ormore of the components of the search head 504 can be implemented asdifferent containers of a single pod, e.g., on a containerizationplatform, such as Docker, the one or more components of the indexingnode can be implemented as different Docker containers managed bysynchronization platforms such as Kubernetes or Swarm. Accordingly,reference to a containerized search head 504 can refer to the searchhead 504 as being a single container or as one or more components of thesearch head 504 being implemented as different, related containers.

In the illustrated embodiment, the search heads 504 includes a searchmaster 512 and one or more search managers 514 to carry out its variousfunctions. However, it will be understood that the search heads 504 caninclude fewer or more components as desired. For example, the searchhead 504 can include multiple search masters 512.

In some embodiments, the search heads 504 can provide information to theresource monitor 508 in order to update the information stored in theresource catalog 510, which may include information such as anidentifier for each search head 504, as well as availabilityinformation. For example, the information in the resource catalog 510may identify and indicate search heads 504 that are instantiated andavailable (e.g., have sufficient bandwidth to process/execute a query),instantiated but are unavailable or unresponsive, and so forth. Theupdated information may indicate the amount of processing resourcescurrently in use by each search head 504, the current utilization rateof each search head 504, the amount of memory currently used by eachsearch head 504, the number of queries being processed/executed by asearch head 504, etc. It should be noted that the information can beprovided ad hoc or on a periodic basis. In some such embodiments, theinformation considered “current” (e.g., the amount of processingresources currently in use) may refer to the most-recent updatedinformation (e.g., the information last provided), the accuracy of whichmay depend on the how recently the information as reported. The searchheads 504 may provide information upon request (e.g., in response to aping) or may provide information based on a set schedule (e.g., sendinformation to the resource monitor 508 on a periodic basis).

3.4.2.1. Search Master

The search master 512 can manage the execution of the various queriesassigned to the search head 504, and can be implemented as a distinctcomputing device, virtual machine, container, container of a pod, or aprocess or thread associated with a container. For example, in certainembodiments, as the search head 504 is assigned a query, the searchmaster 512 can generate one or more search manager(s) 514 to manage thequery. In some cases, the search master 512 generates a separate searchmanager 514 for each query that is received by the search head 504. Inaddition, once a query is completed, the search master 512 can handlethe termination of the corresponding search manager 514.

In certain embodiments, the search master 512 can track and store thequeries assigned to the different search managers 514. Accordingly, if asearch manager 514 becomes unavailable or unresponsive, the searchmaster 512 can generate a new search manager 514 and assign the query tothe new search manager 514. In this way, the search head 504 canincrease the resiliency of the query system 214, reduce delay caused byan unresponsive component, and can aid in providing a statelesssearching service.

In some embodiments, the search master 512 is implemented as abackground process, or daemon, on the search head 504 and the searchmanager(s) 514 are implemented as threads, copies, or forks of thebackground process. In some cases, a search master 512 can copy itself,or fork, to create a search manager 514 or cause a template process tocopy itself, or fork, to create each new search manager 514, etc., inorder to support efficient multithreaded implementations.

3.4.2.2. Search Manager

As mentioned, the search managers 514 can manage the processing andexecution of the queries assigned to the search head 504, and can beimplemented as a distinct computing device, virtual machine, container,container of a pod, or a process or thread associated with a container.In some embodiments, one search manager 514 manages the processing andexecution of one query at a time. In such embodiments, if the searchhead 504 is processing one hundred queries, the search master 512 cangenerate one hundred search managers 514 to manage the one hundredqueries. Upon completing an assigned query, the search manager 514 canawait assignment to a new query or be terminated.

As part of managing the processing and execution of a query, and asdescribed herein, a search manager 514 can parse the query to identifythe set of data and the manner in which the set of data is to beprocessed (e.g., the transformations that are to be applied to the setof data), determine tasks to be performed by the search manager 514 andtasks to be performed by the search nodes 506, identify search nodes 506that are available to execute the query, map search nodes 506 to the setof data that is to be processed, instruct the search nodes 506 toexecute the query and return results, aggregate and/or transform thesearch results from the various search nodes 506, and provide the searchresults to a user and/or to the query acceleration data store 222.

In some cases, to aid in identifying the set of data to be processed,the search manager 514 can consult the data store catalog 220 (depictedin FIG. 2). As described herein, the data store catalog 220 can includeinformation regarding the data stored in common storage 216. In somecases, the data store catalog 220 can include bucket identifiers, a timerange, and a location of the buckets in common storage 216. In addition,the data store catalog 220 can include a tenant identifier and partitionidentifier for the buckets. This information can be used to identifybuckets that include data that satisfies at least a portion of thequery.

As a non-limiting example, consider a search manager 514 that has parseda query to identify the following filter criteria that is used toidentify the data to be processed: time range: past hour, partition:_sales, tenant: ABC, Inc., keyword: Error. Using the received filtercriteria, the search manager 514 can consult the data store catalog 220.Specifically, the search manager 514 can use the data store catalog 220to identify buckets associated with the “_sales” partition and thetenant “ABC, Inc.” and that include data from the “past hour.” In somecases, the search manager 514 can obtain bucket identifiers and locationinformation from the data store catalog 220 for the buckets storing datathat satisfies at least the aforementioned filter criteria. In certainembodiments, if the data store catalog 220 includes keyword pairs, itcan use the keyword “Error” to identify buckets that have at least oneevent that include the keyword “Error.”

Accordingly, the data store catalog 220 can be used to identify relevantbuckets and reduce the number of buckets that are to be searched by thesearch nodes 506. In this way, the data store catalog 220 can decreasethe query response time of the data intake and query system 108. Inaddition, in some embodiments, using the bucket identifiers and/or thelocation information, the search manager 514 can identify and/or assignone or more search nodes 506 to search the corresponding buckets.

In some embodiments, the use of the data store catalog 220 to identifybuckets for searching can contribute to the statelessness of the querysystem 214 and search head 504. For example, if a search head 504 orsearch manager 514 becomes unresponsive or unavailable, the query systemmanager 502 or search master 512, as the case may be, can spin up orassign an additional resource (e.g., new search head 504 or new searchmanager 514) to execute the query. As the bucket information ispersistently stored in the data store catalog 220, data lost due to theunavailability or unresponsiveness of a component of the query system214 can be recovered by using the bucket information in the data storecatalog 220.

In certain embodiments, to identify search nodes 506 that are availableto execute the query, the search manager 514 can consult the resourcecatalog 510. As described herein, the resource catalog 510 can includeinformation regarding the search nodes 506 (and search heads 504). Insome cases, the resource catalog 510 can include an identifier for eachsearch node 506, as well as utilization and availability information.For example, the resource catalog 510 can identify search nodes 506 thatare instantiated but are unavailable or unresponsive. In addition, theresource catalog 510 can identify the utilization rate of the searchnodes 506. For example, the resource catalog 510 can identify searchnodes 506 that are working at maximum capacity or at a utilization ratethat satisfies utilization threshold, such that the search node 506should not be used to execute additional queries for a time.

In addition, the resource catalog 510 can include architecturalinformation about the search nodes 506. For example, the resourcecatalog 510 can identify search nodes 506 that share a data store and/orare located on the same computing device, or on computing devices thatare co-located. In some embodiments, the search manager 514 can consultthe resource monitor 508, which can retrieve the relevant informationfrom the resource catalog 510 and provide it to the search manager 514.

Accordingly, in some embodiments, based on the receipt of a query, asearch manager 514 can consult the resource catalog 510 (or the resourcemonitor 508) for search nodes 506 that are available to execute thereceived query. Based on the consultation of the resource catalog 510(or the resource monitor 508), the search manager 514 can determinewhich search nodes 506 to assign to execute the query.

In some embodiments, the query system 214 (non-limiting examples: searchmanager 514 and/or resource monitor 508) can use a search node mappingpolicy to identify and/or assign search nodes 506 for a particular queryor to access particular buckets as part of the query. In certainembodiments, the search node mapping policy can include sub-policies,such as a search head-node mapping policy and/or a search node-datamapping policy (described below).

Although reference is made herein to search manager 514 or resourcemonitor 508 identifying/assigning search nodes 506 for a particularquery or bucket, it will be understood that any one any combination ofthe components of the query system 214 can make the assignments and/oruse the search node mapping policy (or one of its sub-policies). Forexample, the search manager 514 can request one or more available searchnodes 506 from the resource monitor 508 and then assign or map one ormore of the available search nodes for the query, and/or assign thesearch nodes 506 to process particular buckets, etc. As another example,the search manager 514 can request one or more search nodes 506 and theresource monitor 508 can identify available search nodes 506, assign ormap them to the search manager 514 for the query, inform the searchmanager 514 of the assigned search nodes 506, and/or assign the searchnodes 506 to process particular buckets, etc. As another example, theresource monitor 508 may use a one search node mapping policy (e.g.,search head-node mapping policy) to identify one or more search nodes506 for a particular query and the search manager 514 may use adifferent search node mapping policy (e.g., search node-data mappingpolicy) to determine which buckets are to be accessed by which of theassigned search nodes, etc.

As part of the query execution, the search manager 514 can instruct thesearch nodes 506 to execute the query (or sub-query) on the assignedbuckets. As described herein, the search manager 514 can generatespecific queries or sub-queries for the individual search nodes 506. Thesearch nodes 506 can use the queries to execute the query on the bucketsassigned thereto.

In some embodiments, the search manager 514 stores the sub-queries andbucket assignments for the different search nodes 506. Storing thesub-queries and bucket assignments can contribute to the statelessnessof the query system 214. For example, in the event an assigned searchnode 506 becomes unresponsive or unavailable during the query execution,the search manager 514 can re-assign the sub-query and bucketassignments of the unavailable search node 506 to one or more availablesearch nodes 506 or identify a different available search node 506 fromthe resource catalog 510 to execute the sub-query. In certainembodiments, the query system manager 502 can generate an additionalsearch node 506 to execute the sub-query of the unavailable search node506. Accordingly, the query system 214 can quickly recover from anunavailable or unresponsive component without data loss and whilereducing or minimizing delay.

During the query execution, the search manager 514 can monitor thestatus of the assigned search nodes 506. In some cases, the searchmanager 514 can ping or set up a communication link between it and thesearch nodes 506 assigned to execute the query. As mentioned, the searchmanager 514 can store the mapping of the buckets to the search nodes506. Accordingly, in the event a particular search node 506 becomesunavailable or is unresponsive, the search manager 514 can assign adifferent search node 506 to complete the execution of the query for thebuckets assigned to the unresponsive search node 506.

In some cases, as part of the status updates to the search manager 514,the search nodes 506 can provide the search manager with partial resultsand information regarding the buckets that have been searched. Inresponse, the search manager 514 can store the partial results andbucket information in persistent storage. Accordingly, if a search node506 partially executes the query and becomes unresponsive orunavailable, the search manager 514 can assign a different search node506 to complete the execution, as described above. For example, thesearch manager 514 can assign a search node 506 to execute the query onthe buckets that were not searched by the unavailable search node 506.In this way, the search manager 514 can more quickly recover from anunavailable or unresponsive search node 506 without data loss and whilereducing or minimizing delay.

As the search manager 514 receives query results from the differentsearch nodes 506, it can process the data. In some cases, the searchmanager 514 processes the partial results as it receives them. Forexample, if the query includes a count, the search manager 514 canincrement the count as it receives the results from the different searchnodes 506. In certain cases, the search manager 514 waits for thecomplete results from the search nodes before processing them. Forexample, if the query includes a command that operates on a result set,or a partial result set, e.g., a stats command (e.g., a command thatcalculates one or more aggregate statistics over the results set, e.g.,average, count, or standard deviation, as examples), the search manager514 can wait for the results from all the search nodes 506 beforeexecuting the stats command.

As the search manager 514 processes the results or completes processingthe results, it can store the results in the query acceleration datastore 222 or communicate the results to a client device 204. Asdescribed herein, results stored in the query acceleration data store222 can be combined with other results over time. For example, if thequery system 214 receives an open-ended query (e.g., no set end time),the search manager 515 can store the query results over time in thequery acceleration data store 222. Query results in the queryacceleration data store 222 can be updated as additional query resultsare obtained. In this manner, if an open-ended query is run at time B,query results may be stored from initial time A to time B. If the sameopen-ended query is run at time C, then the query results from the prioropen-ended query can be obtained from the query acceleration data store222 (which gives the results from time A to time B), and the query canbe run from time B to time C and combined with the prior results, ratherthan running the entire query from time A to time C. In this manner, thecomputational efficiency of ongoing search queries can be improved.

3.4.2.2.1. Search Head-Node Mapping Policy

As described, the search node mapping policy can include one or moresub-policies. In certain embodiments, the search node mapping policy caninclude search head-node mapping policy, which can be used by the searchmanager 514 and/or resource monitor 508 to identify the search nodes 506to use for a query or to assign search nodes 506 to a search head 504,to a search manager 514, or to a data identifier associated with thequery. In some embodiments, the search head-node mapping policy canindicate that search nodes 506 are to be assigned for a particular queryrandomly, based on an order (e.g., sequentially assign search nodes 506as queries are received), based on availability, based on previousassignments, based on a data identifier associated with the query, etc.

As described herein, each query received by the query system 214 can beassociated with a data identifier that, for example, relates to aparticular tenant, data source 202, index, or sourcetype, etc. In somecases, the resource monitor 508 can use the data identifier associatedwith a particular query to assign the search nodes 506 for theparticular query.

In some embodiments, the resource catalog 510 can store a search nodeassignment listing that associates search nodes 506 with dataidentifiers. In some such embodiments, the search head-node mappingpolicy can indicate that the resource monitor 508 is to use the listingto determine whether a particular data identifier is associated with oneor more search node(s) 506. As a non-limiting example, if the resourcemonitor 508 receives a request from a search manager 514 to map one ormore search nodes 506 to a query associated with a data identifier, theresource monitor 508 can use the search node assignment listing toidentify the search node(s) 506 that are to execute the query. In somesuch embodiments, the search node assignment listing can includemultiple search nodes 506 associated with the data identifier and theresource monitor 508 can assign multiple search nodes 506 based on theirdetermined availability (non-limiting example: metrics relating to thatsearch node 506 satisfy one or more metrics thresholds). Accordingly,based on the data identifier and the determined availability of thesearch nodes 506, the resource monitor 508 can assign one or more searchnodes 506 to execute the query.

In some cases, search heads 504 can store a search node assignmentlisting. In certain embodiments, the search node assignment listingstored by the search heads 504 can be the same as the search nodeassignment listing stored by the resource catalog 510. For example, theresource monitor 508 can generate the search node assignment listing forthe resource catalog 510 and distribute the search node assignmentlisting to the instantiated search heads 504 and/or search managers 514.In some embodiments, the search node assignment listing stored by thesearch heads 504 can be different from the search node assignmentlisting stored by the resource catalog 510. For example, the search nodeassignment listing stored by the resource catalog 510 can correspond tosearch node assignments across some or all search heads 504 or searchmanagers 514, whereas the search node assignment listing for aparticular search head 504 or search manager 514 may only include thesearch node assignments for queries that it (or a group of relatedsearch heads 504) has processed.

As another example, in some embodiments, the search head-node mappingpolicy can indicate that the resource monitor 508 is to use a hashfunction or other function to map one or more particular search nodes506 to a data identifier (or query) or search manager 514. In certainembodiments, the resource monitor 508 can hash the data identifier, anduse the output of the hash to identify available search node(s) 506. Forexample, if there are ten search nodes 506 and three are to be used toexecute a query associated with a particular tenant, the resourcemonitor 508 can assign three search nodes 506 to the search manager 514that is managing the query based on a hash of a tenant identifier of thetenant. In this way, other queries associated with the same tenant canbe assigned to the same search nodes 506, or the query system 214 canincrease the likelihood that other queries associated with the sametenant can be assigned to the same search nodes 506.

In certain embodiments, the search head-node mapping policy can indicatethat the resource monitor 508 is to use a consistent hash to map thesearch node(s) 506 to the search manager 514 for the query. As part ofusing a consistent hash, the resource monitor 508 can perform a hash onidentifiers of the search nodes 506 and map the hash values to a hashring. The resource monitor 508 can then perform a hash on the dataidentifier associated with the query (non-limiting example: tenantidentifier of the tenant whose data is to be queried). Based on thelocation of the resulting hash value on the hash ring, the resourcemonitor 508 can assign one or more search nodes 506 for the query. Incertain cases, the resource monitor 508 can assign one or more searchnodes 506 for the query based on the location of the hashed dataidentifier to the location of the hashed search node identifiers on thehash ring. For example, if three search nodes 506 are to be used for thequery, the resource monitor 508 can map the data identifier to the threesearch nodes 506 whose hashed node identifier is closest to or next inline (in a particular direction) on the hash ring to the hashed dataidentifier. In some cases, the resource monitor 508 maps the dataidentifier to multiple search nodes 506, for example, by selecting twoor more search nodes 506 that have a position on the hash ring that isclosest, or next in line, to the hash value of the data identifier whenfitted on the hash ring. In some cases, the consistent hash function canbe configured such that even with a different number of search nodes 506being instantiated in the query system 214, the output of the hashingwill consistently identify the same search node(s) 506, or have anincreased probability of identifying the same search node(s) 506 forqueries from the same tenants.

In some instances, the search head-node mapping policy can indicate thatthe resource monitor 508 is to map search node 506 for a query randomly,or in a simple sequence (e.g., a first search node(s) 506 is mapped to afirst query, a second search node 506 is mapped to a second query,etc.). In other instances, as discussed, the search head-node mappingpolicy can indicate that the resource monitor 508 is to map search nodes506 to queries/data identifiers/search manager 514 based on previousmappings.

In certain embodiments, according to the search head-node mappingpolicy, search nodes 506 may be mapped to queries/dataidentifiers/search managers 514 based on overlaps of computing resourcesof the search nodes 506. For example, if a search manager 514 isinstantiated on the same host system as a search node 506, the resourcemonitor 508 can assign the search node 506 to the query that the searchmanager 514 is managing.

Accordingly, it will be understood that the resource monitor 508 can mapany search node 506 to any query/data identifier/search manager 514, andthat the search head-node mapping policy can indicate that the resourcemonitor 508 is to use any one or any combination of the above-describedmechanisms to map search nodes 506 to search managers 514/queries/dataidentifiers.

Based on the determined query/data identifier/search manager 514 tosearch node(s) 506 mapping, the resource monitor 508 can respond to asearch manager 514. The response can include an identifier for theassigned search nodes 506 that are to execute the query. In certainembodiments, the response can include instructions that the identifiedsearch node(s) 506 are to be used for some or all of the queryexecution.

In some embodiments, the resource monitor 508 can use different policiesfor queries associated with different data identifiers. For example, forqueries associated with Tenant A, the resource monitor may use aconsistent hashing algorithm to assign search nodes 506. For queriesassociated with Tenant B, the resource monitor may use a pre-configuredset of search nodes 506 to execute the query. Similarly, the resourcemonitor 508 can assign different numbers of search nodes for differentqueries based on the data identifiers associated with the queries orbased on some other priority indicator. For example, the resourcemonitor 508 may dynamically assign up to twelve search nodes for queriesassociated with Tenant A based on the size of the query (e.g., amount ofdata to be processed as part of the query) and may consistently assignfour search nodes for queries associated with Tenant B regardless of thesize of the query. In some cases, the number of search nodes 506assigned can be based on a priority level associated with the dataidentifier or the query. For example, tenants or queries associated witha higher priority level can be allocated a larger number of search nodes506. In certain cases, the priority level can be based on an indicationreceived from a user, the identity of the tenant, etc.

3.4.2.2.2 Search Node-Data Mapping Policy

As described, the search node mapping policy can include a searchnode-data mapping policy, which can be used to map search nodes 506 tothe data that is to be processed. In some embodiments, the searchnode-data mapping policy can indicate how search nodes 506 are to beassigned to data (e.g., buckets) and when search nodes 506 are to beassigned to (and instructed to search) the data or buckets. Asmentioned, the search node-data mapping policy can be used alone or inconjunction with the search head-node mapping policy (non-limitingexample: the number and identity of search nodes 506 for a query areidentified based on a search head-node mapping policy and the dataaccessed by the assigned search nodes is determined based on a searchnode-data mapping policy) as part of the search node mapping policy.

In some cases, the search manager 514 can map the search nodes 506 tobuckets that include data that satisfies at least a portion of thequery. For example, in some cases, the search manager 514 can consultthe data store catalog 220 to obtain bucket identifiers of buckets thatinclude data that satisfies at least a portion of the query, e.g., as anon-limiting example, to obtain bucket identifiers of buckets thatinclude data associated with a particular time range. Based on theidentified buckets and search nodes 506, the search manager 514 candynamically assign (or map) search nodes 506 to individual bucketsaccording to a search node-data mapping policy.

In some embodiments, the search node-data mapping policy can indicatethat the search manager 514 is to assign all buckets to search nodes 506as a single operation. For example, where ten buckets are to be searchedby five search nodes 506, the search manager 514 can assign two bucketsto a first search node 506, two buckets to a second search node 506,etc. In another embodiment, the search node-data mapping policy canindicate that the search manager 514 is to assign buckets iteratively.For example, where ten buckets are to be searched by five search nodes506, the search manager 514 can initially assign five buckets (e.g., onebuckets to each search node 506), and assign additional buckets to eachsearch node 506 as the respective search nodes 506 complete theexecution on the assigned buckets.

Retrieving buckets from common storage 216 to be searched by the searchnodes 506 can cause delay or may use a relatively high amount of networkbandwidth or disk read/write bandwidth. In some cases, a local or shareddata store associated with the search nodes 506 may include a copy of abucket that was previously retrieved from common storage 216.Accordingly, to reduce delay caused by retrieving buckets from commonstorage 216, the search node-data mapping policy can indicate that thesearch manager 514 is to assign, preferably assign, or attempt to assignthe same search node 506 to search the same bucket over time. In thisway, the assigned search node 506 can keep a local copy of the bucket onits data store (or a data store shared between multiple search nodes506) and avoid the processing delays associated with obtaining thebucket from the common storage 216.

In certain embodiments, the search node-data mapping policy can indicatethat the search manager 514 is to use a consistent hash function orother function to consistently map a bucket to a particular search node506. The search manager 514 can perform the hash using the bucketidentifier obtained from the data store catalog 220, and the output ofthe hash can be used to identify the search node 506 assigned to thebucket. In some cases, the consistent hash function can be configuredsuch that even with a different number of search nodes 506 beingassigned to execute the query, the output will consistently identify thesame search node 506, or have an increased probability of identifyingthe same search node 506. For example, as described herein, the hashingfunction can include placing the hash of the search node identifiers andthe hash of the bucket identifiers on a hash ring, and assigning bucketsto the search nodes based on the proximity of the hash of the bucketidentifiers to the hash of the search node identifiers.

In certain embodiments where the query system 214 uses a hash ring aspart of a search head-node mapping policy and a hash ring as part of asearch node-data mapping policy, the hash rings can be different. Forexample, the first hash ring can include hash values of the indexingnode identifiers and the data identifier associated with the query, andthe second hash ring can include hash values of the bucket identifiersand indexing node identifiers. In some such embodiments, the first hashring can be used to assign search nodes 506 for the query and the secondhash ring can be used to assign buckets to the search nodes 506 assignedfor the query.

In some embodiments, the query system 214 can store a mapping of searchnodes 506 to bucket identifiers. The search node-data mapping policy canindicate that the search manager 514 is to use the mapping to determinewhether a particular bucket has been assigned to a search node 506. Ifthe bucket has been assigned to a particular search node 506 and thatsearch node 506 is available, then the search manager 514 can assign thebucket to the search node 506. If the bucket has not been assigned to aparticular search node 506, the search manager 514 can use a hashfunction to identify a search node 506 for assignment. Once assigned,the search manager 514 can store the mapping for future use.

In certain cases, the search node-data mapping policy can indicate thatthe search manager 514 is to use architectural information about thesearch nodes 506 to assign buckets. For example, if the identifiedsearch node 506 is unavailable or its utilization rate satisfies athreshold utilization rate, the search manager 514 can determine whetheran available search node 506 shares a data store with the unavailablesearch node 506. If it does, the search manager 514 can assign thebucket to the available search node 506 that shares the data store withthe unavailable search node 506. In this way, the search manager 514 canreduce the likelihood that the bucket will be obtained from commonstorage 216, which can introduce additional delay to the query while thebucket is retrieved from common storage 216 to the data store shared bythe available search node 506.

In some instances, the search node-data mapping policy can indicate thatthe search manager 514 is to assign buckets to search nodes 506randomly, or in a simple sequence (e.g., a first search nodes 506 isassigned a first bucket, a second search node 506 is assigned a secondbucket, etc.). In other instances, as discussed, the search node-datamapping policy can indicate that the search manager 514 is to assignbuckets to search nodes 506 based on buckets previously assigned to asearch nodes 506, in a prior or current search. As mentioned above, insome embodiments each search node 506 may be associated with a localdata store or cache of information (e.g., in memory of the search nodes506, such as random access memory [“RAM”], disk-based cache, a datastore, or other form of storage). Each search node 506 can store copiesof one or more buckets from the common storage 216 within the localcache, such that the buckets may be more rapidly searched by searchnodes 506. The search manager 514 (or cache manager 516) can maintain orretrieve from search nodes 506 information identifying, for eachrelevant search node 506, what buckets are copied within local cache ofthe respective search nodes 506. In the event that the search manager514 determines that a search node 506 assigned to execute a search haswithin its data store or local cache a copy of an identified bucket, thesearch manager 514 can preferentially assign the search node 506 tosearch that locally-cached bucket.

In still more embodiments, according to the search node-data mappingpolicy, search nodes 506 may be assigned based on overlaps of computingresources of the search nodes 506. For example, where a containerizedsearch node 506 is to retrieve a bucket from common storage 216 (e.g.,where a local cached copy of the bucket does not exist on the searchnode 506), such retrieval may use a relatively high amount of networkbandwidth or disk read/write bandwidth. Thus, assigning a secondcontainerized search node 506 instantiated on the same host computingdevice might be expected to strain or exceed the network or diskread/write bandwidth of the host computing device. For this reason, insome embodiments, according to the search node-data mapping policy, thesearch manager 514 can assign buckets to search nodes 506 such that twocontainerized search nodes 506 on a common host computing device do notboth retrieve buckets from common storage 216 at the same time.

Further, in certain embodiments, where a data store that is sharedbetween multiple search nodes 506 includes two buckets identified forthe search, the search manager 514 can, according to the searchnode-data mapping policy, assign both such buckets to the same searchnode 506 or to two different search nodes 506 that share the data store,such that both buckets can be searched in parallel by the respectivesearch nodes 506.

The search node-data mapping policy can indicate that the search manager514 is to use any one or any combination of the above-describedmechanisms to assign buckets to search nodes 506. Furthermore, thesearch node-data mapping policy can indicate that the search manager 514is to prioritize assigning search nodes 506 to buckets based on any oneor any combination of: assigning search nodes 506 to process bucketsthat are in a local or shared data store of the search nodes 506,maximizing parallelization (e.g., assigning as many different searchnodes 506 to execute the query as are available), assigning search nodes506 to process buckets with overlapping timestamps, maximizingindividual search node 506 utilization (e.g., ensuring that each searchnode 506 is searching at least one bucket at any given time, etc.), orassigning search nodes 506 to process buckets associated with aparticular tenant, user, or other known feature of data stored withinthe bucket (e.g., buckets holding data known to be used intime-sensitive searches may be prioritized). Thus, according to thesearch node-data mapping policy, the search manager 514 can dynamicallyalter the assignment of buckets to search nodes 506 to increase theparallelization of a search, and to increase the speed and efficiencywith which the search is executed.

It will be understood that the search manager 514 can assign any searchnode 506 to search any bucket. This flexibility can decrease queryresponse time as the search manager can dynamically determine whichsearch nodes 506 are best suited or available to execute the query ondifferent buckets. Further, if one bucket is being used by multiplequeries, the search manager 515 can assign multiple search nodes 506 tosearch the bucket. In addition, in the event a search node 506 becomesunavailable or unresponsive, the search manager 514 can assign adifferent search node 506 to search the buckets assigned to theunavailable search node 506.

In some embodiments, the resource monitor 508 can use different searchnode-data mapping policies for queries associated with different dataidentifiers. For example, for queries associated with Tenant A, theresource monitor may use a consistent hashing algorithm to assignbuckets to search nodes 506. For queries associated with Tenant B, theresource monitor may iteratively assign buckets to search nodes 506 toexecute the query. Similarly, as described herein with reference to thesearch head-node mapping policy, a different number of search nodes 506can be assigned for queries based on a priority level of the queryand/or the data identifier associated with the query.

3.4.3. Search Nodes

As described herein, the search nodes 506 can be the primary queryexecution engines for the query system 214, and can be implemented asdistinct computing devices, virtual machines, containers, container of apods, or processes or threads associated with one or more containers.Accordingly, each search node 506 can include a processing device and adata store, as depicted at a high level in FIG. 5. Depending on theembodiment, the processing device and data store can be dedicated to thesearch node (e.g., embodiments where each search node is a distinctcomputing device) or can be shared with other search nodes or componentsof the data intake and query system 108 (e.g., embodiments where thesearch nodes are implemented as containers or virtual machines or wherethe shared data store is a networked data store, etc.).

In some embodiments, the search nodes 506 can obtain and search bucketsidentified by the search manager 514 that include data that satisfies atleast a portion of the query, identify the set of data within thebuckets that satisfies the query, perform one or more transformations onthe set of data, and communicate the set of data to the search manager514. Individually, a search node 506 can obtain the buckets assigned toit by the search manager 514 for a particular query, search the assignedbuckets for a subset of the set of data, perform one or moretransformation on the subset of data, and communicate partial searchresults to the search manager 514 for additional processing andcombination with the partial results from other search nodes 506.

In some cases, the buckets to be searched may be located in a local datastore of the search node 506 or a data store that is shared betweenmultiple search nodes 506. In such cases, the search nodes 506 canidentify the location of the buckets and search the buckets for the setof data that satisfies the query.

In certain cases, the buckets may be located in the common storage 216.In such cases, the search nodes 506 can search the buckets in the commonstorage 216 and/or copy the buckets from the common storage 216 to alocal or shared data store and search the locally stored copy for theset of data. As described herein, the cache manager 516 can coordinatewith the search nodes 506 to identify the location of the buckets(whether in a local or shared data store or in common storage 216)and/or obtain buckets stored in common storage 216.

Once the relevant buckets (or relevant files of the buckets) areobtained, the search nodes 506 can search their contents to identify theset of data to be processed. In some cases, upon obtaining a bucket fromthe common storage 216, a search node 306 can decompress the bucket froma compressed format, and accessing one or more files stored within thebucket. In some cases, the search node 306 references a bucket summaryor manifest to locate one or more portions (e.g., records or individualfiles) of the bucket that potentially contain information relevant tothe search.

In some cases, the search nodes 506 can use all of the files of a bucketto identify the set of data. In certain embodiments, the search nodes506 use a subset of the files of a bucket to identify the set of data.For example, in some cases, a search node 506 can use an inverted index,bloom filter, or bucket summary or manifest to identify a subset of theset of data without searching the raw machine data of the bucket. Incertain cases, the search node 506 uses the inverted index, bloomfilter, bucket summary, and raw machine data to identify the subset ofthe set of data that satisfies the query.

In some embodiments, depending on the query, the search nodes 506 canperform one or more transformations on the data from the buckets. Forexample, the search nodes 506 may perform various data transformations,scripts, and processes, e.g., a count of the set of data, etc.

As the search nodes 506 execute the query, they can provide the searchmanager 514 with search results. In some cases, a search node 506provides the search manager 514 results as they are identified by thesearch node 506, and updates the results over time. In certainembodiments, a search node 506 waits until all of its partial resultsare gathered before sending the results to the search manager 514.

In some embodiments, the search nodes 506 provide a status of the queryto the search manager 514. For example, an individual search node 506can inform the search manager 514 of which buckets it has searchedand/or provide the search manager 514 with the results from the searchedbuckets. As mentioned, the search manager 514 can track or store thestatus and the results as they are received from the search node 506. Inthe event the search node 506 becomes unresponsive or unavailable, thetracked information can be used to generate and assign a new search node506 to execute the remaining portions of the query assigned to theunavailable search node 506.

The search nodes 506 may provide information to the resource monitor 508in order to update the information stored in the resource catalog 510,which may include information such as an identifier for each search node506, as well as availability, responsiveness, and utilizationinformation. For example, the updated information in the resourcecatalog 510 may identify and indicate search nodes 506 that areinstantiated and currently available (e.g., currently not being used toexecute queries), instantiated but are currently unavailable orunresponsive, and so forth. The updated information may indicate theamount of processing resources currently in use by each search node 506,the current utilization rate of each search node 506, the amount ofmemory currently used by each search node 506, etc. The updatedinformation may also indicate a node type associated with each searchnode 506, the cache hit ratio for each search node 506, and so forth. Itshould be noted that the information can be provided on-the-fly or on aperiodic basis, and in the latter case, the information considered“current” (e.g., the amount of processing resources currently in use)may refer to the most-recent updated information (e.g., the informationlast provided), which can be accurate if updated information is providedrelatively frequently. The search nodes 506 may provide information uponrequest (e.g., in response to a ping) or may provide information basedon a set schedule (e.g., send information to the resource monitor 508 ona periodic basis).

3.4.4. Cache Manager

As mentioned, the cache manager 516 can communicate with the searchnodes 506 to obtain or identify the location of the buckets assigned tothe search nodes 506, and can be implemented as a distinct computingdevice, virtual machine, container, a pod, or a process or threadassociated with a container.

In some embodiments, based on the receipt of a bucket assignment, asearch node 506 can provide the cache manager 516 with an identifier ofthe bucket that it is to search, a file associated with the bucket thatit is to search, and/or a location of the bucket. In response, the cachemanager 516 can determine whether the identified bucket or file islocated in a local or shared data store or is to be retrieved from thecommon storage 216.

As mentioned, in some cases, multiple search nodes 506 can share a datastore. Accordingly, if the cache manager 516 determines that therequested bucket is located in a local or shared data store, the cachemanager 516 can provide the search node 506 with the location of therequested bucket or file. In certain cases, if the cache manager 516determines that the requested bucket or file is not located in the localor shared data store, the cache manager 516 can request the bucket orfile from the common storage 216, and inform the search node 506 thatthe requested bucket or file is being retrieved from common storage 216.

In some cases, the cache manager 516 can request one or more filesassociated with the requested bucket prior to, or in place of,requesting all contents of the bucket from the common storage 216. Forexample, a search node 506 may request a subset of files from aparticular bucket. Based on the request and a determination that thefiles are located in common storage 216, the cache manager 516 candownload or obtain the identified files from the common storage 216.

In some cases, based on the information provided from the search node506, the cache manager 516 may be unable to uniquely identify arequested file or files within the common storage 216. Accordingly, incertain embodiments, the cache manager 516 can retrieve a bucket summaryor manifest file from the common storage 216 and provide the bucketsummary to the search node 506. In some cases, the cache manager 516 canprovide the bucket summary to the search node 506 while concurrentlyinforming the search node 506 that the requested files are not locatedin a local or shared data store and are to be retrieved from commonstorage 216.

Using the bucket summary, the search node 506 can uniquely identify thefiles to be used to execute the query. Using the unique identification,the cache manager 516 can request the files from the common storage 216.Accordingly, rather than downloading the entire contents of the bucketfrom common storage 216, the cache manager 516 can download thoseportions of the bucket that are to be used by the search node 506 toexecute the query. In this way, the cache manager 516 can decrease theamount of data sent over the network and decrease the search time.

As a non-limiting example, a search node 506 may determine that aninverted index of a bucket is to be used to execute a query. Forexample, the search node 506 may determine that all the information thatit needs to execute the query on the bucket can be found in an invertedindex associated with the bucket. Accordingly, the search node 506 canrequest the file associated with the inverted index of the bucket fromthe cache manager 516. Based on a determination that the requested fileis not located in a local or shared data store, the cache manager 516can determine that the file is located in the common storage 216.

As the bucket may have multiple inverted indexes associated with it, theinformation provided by the search node 506 may be insufficient touniquely identify the inverted index within the bucket. To address thisissue, the cache manager 516 can request a bucket summary or manifestfrom the common storage 216, and forward it to the search node 506. Thesearch node 506 can analyze the bucket summary to identify theparticular inverted index that is to be used to execute the query, andrequest the identified particular inverted index from the cache manager516 (e.g., by name and/or location). Using the bucket manifest and/orthe information received from the search node 506, the cache manager 516can obtain the identified particular inverted index from the commonstorage 216. By obtaining the bucket manifest and downloading therequested inverted index instead of all inverted indexes or files of thebucket, the cache manager 516 can reduce the amount of data communicatedover the network and reduce the search time for the query.

In some cases, when requesting a particular file, the search node 506can include a priority level for the file. For example, the files of abucket may be of different sizes and may be used more or less frequentlywhen executing queries. For example, the bucket manifest may be arelatively small file. However, if the bucket is searched, the bucketmanifest can be a relatively valuable file (and frequently used) becauseit includes a list or index of the various files of the bucket.Similarly, a bloom filter of a bucket may be a relatively small file butfrequently used as it can relatively quickly identify the contents ofthe bucket. In addition, an inverted index may be used more frequentlythan raw data of a bucket to satisfy a query.

Accordingly, to improve retention of files that are commonly used in asearch of a bucket, the search node 506 can include a priority level forthe requested file. The cache manager 516 can use the priority levelreceived from the search node 506 to determine how long to keep, or whento evict, the file from the local or shared data store. For example,files identified by the search node 506 as having a higher prioritylevel can be stored for a greater period of time than files identifiedas having a lower priority level.

Furthermore, the cache manager 516 can determine what data and how longto retain the data in the local or shared data stores of the searchnodes 506 based on a bucket caching policy. In some cases, the bucketcaching policy can rely on any one or any combination of the prioritylevel received from the search nodes 506 for a particular file, leastrecently used, most recent in time, or other policies to indicate howlong to retain files in the local or shared data store.

In some instances, according to the bucket caching policy, the cachemanager 516 or other component of the query system 214 (e.g., the searchmaster 512 or search manager 514) can instruct search nodes 506 toretrieve and locally cache copies of various buckets from the commonstorage 216, independently of processing queries. In certainembodiments, the query system 214 is configured, according to the bucketcaching policy, such that one or more buckets from the common storage216 (e.g., buckets associated with a tenant or partition of a tenant) oreach bucket from the common storage 216 is locally cached on at leastone search node 506.

In some embodiments, according to the bucket caching policy, the querysystem 214 is configured such that at least one bucket from the commonstorage 216 is locally cached on at least two search nodes 506. Cachinga bucket on at least two search nodes 506 may be beneficial, forexample, in instances where different queries both require searching thebucket (e.g., because the at least search nodes 506 may process theirrespective local copies in parallel). In still other embodiments, thequery system 214 is configured, according to the bucket caching policy,such that one or more buckets from the common storage 216 or all bucketsfrom the common storage 216 are locally cached on at least a givennumber n of search nodes 506, wherein n is defined by a replicationfactor on the system 108. For example, a replication factor of five maybe established to ensure that five copies of a bucket are locally cachedacross different search nodes 506.

In certain embodiments, the search manager 514 (or search master 512)can assign buckets to different search nodes 506 based on time. Forexample, buckets that are less than one day old can be assigned to afirst group of search nodes 506 for caching, buckets that are more thanone day but less than one week old can be assigned to a different groupof search nodes 506 for caching, and buckets that are more than one weekold can be assigned to a third group of search nodes 506 for caching. Incertain cases, the first group can be larger than the second group, andthe second group can be larger than the third group. In this way, thequery system 214 can provide better/faster results for queries searchingdata that is less than one day old, and so on, etc. It will beunderstood that the search nodes can be grouped and assigned buckets ina variety of ways. For example, search nodes 506 can be grouped based ona tenant identifier, index, etc. In this way, the query system 214 candynamically provide faster results based any one or any number offactors.

In some embodiments, when a search node 506 is added to the query system214, the cache manager 516 can, based on the bucket caching policy,instruct the search node 506 to download one or more buckets from commonstorage 216 prior to receiving a query. In certain embodiments, thecache manager 516 can instruct the search node 506 to download specificbuckets, such as most recent in time buckets, buckets associated with aparticular tenant or partition, etc. In some cases, the cache manager516 can instruct the search node 506 to download the buckets before thesearch node 506 reports to the resource monitor 508 that it is availablefor executing queries. It will be understood that other components ofthe query system 214 can implement this functionality, such as, but notlimited to the query system manager 502, resource monitor 508, searchmanager 514, or the search nodes 506 themselves.

In certain embodiments, when a search node 506 is removed from the querysystem 214 or becomes unresponsive or unavailable, the cache manager 516can identify the buckets that the removed search node 506 wasresponsible for and instruct the remaining search nodes 506 that theywill be responsible for the identified buckets. In some cases, theremaining search nodes 506 can download the identified buckets fromcommon storage 216 or retrieve them from the data store associated withthe removed search node 506.

In some cases, the cache manager 516 can change the bucket-search node506 assignments, such as when a search node 506 is removed or added. Incertain embodiments, based on a reassignment, the cache manager 516 caninform a particular search node 506 to remove buckets to which it is nolonger assigned, reduce the priority level of the buckets, etc. In thisway, the cache manager 516 can make it so the reassigned bucket will beremoved more quickly from the search node 506 than it otherwise wouldwithout the reassignment. In certain embodiments, the search node 506that receives the new for the bucket can retrieve the bucket from thenow unassigned search node 506 and/or retrieve the bucket from commonstorage 216.

3.4.5. Resource Monitor and Catalog

The resource monitor 508 can monitor search nodes and populate theresource catalog 510 with relevant information, and can be implementedas a distinct computing device, virtual machine, container, container ofa pod, or a process or thread associated with a container.

Although the resource monitor 508 and resource catalog 510 are shown asseparate components, it will be understood that they can be implementedas part of the same machine, host system, isolated executionenvironment, pod, container, virtual machine, etc. Furthermore, althoughseparate resource monitors 418, 508 and resource catalog 420 and 510 areshown for the indexing system 212 and the query system 214, it will beunderstood that the resource monitors 418, 508 and resource catalog 420and 510 can be implemented as part of the same machine, isolatedexecution environment, pod, container, etc. For example, the indexingsystem 212 and the query system 214 can interact with a resource monitorand resource catalog in a manner similar to which these systems (ortheir components) interact with the common storage 216, data storecatalog 220, metadata catalog 221, etc. Thus, the illustratedembodiments, should not be construed as limiting the resource monitors418, 508 and resource catalog 420 and 510 to a particular architectureor design.

In some cases, the resource monitor 508 can ping the search nodes 506over time to determine their availability, responsiveness, and/orutilization rate. In certain embodiments, each search node 506 caninclude a monitoring module that provides performance metrics or statusupdates about the search node 506 to the resource monitor 508. Forexample, the monitoring module can indicate the amount of processingresources in use by the search node 506, the utilization rate of thesearch node 506, the amount of memory used by the search node 506, etc.In certain embodiments, the resource monitor 508 can determine that asearch node 506 is unavailable or failing based on the data in thestatus update or absence of a state update from the monitoring module ofthe search node 506.

In certain embodiments, each search head 504 can include a monitoringmodule that provides performance metrics or status updates (e.g.,availability information) about the search node 506 to the resourcemonitor 508, along with information such as an identifier for thatsearch head 504. For example, the monitoring module can indicate thenumber of queries being processed by the search head 504, the amount ofprocessing resources in use by the search head 504, the amount of memoryused by the search head 504, and so forth. In certain embodiments, theresource monitor 508 can determine that a search head 504 is unavailableor failing based on the data in the status update or absence of a stateupdate from the monitoring module of the search node 506. Thus, theresource monitor 508 may be able to identify and indicate search heads504 that are instantiated and available (e.g., include sufficientbandwidth to process one or more additional queries), instantiated butare unavailable or unresponsive, and so forth. Using the informationobtained from the search heads 504 and search nodes 506, the resourcemonitor 508 can populate the resource catalog 510 and update it overtime.

As the availability, responsiveness, and/or utilization change for thedifferent search heads 504 and/or search nodes 506, the resource monitor508 can update the resource catalog 510. In this way, the resourcecatalog 510 can retain an up-to-date list of search heads 504 availableto handle queries and/or search nodes 506 available to execute a query.

Furthermore, as search heads 504 and/or search nodes 506 areinstantiated (or at other times), the newly-instantiated search heads504 and/or search nodes 506 can provide information to the resourcemonitor 508, which can update the resource catalog 510 with informationabout the newly-instantiated search heads 504 and/or search nodes 506,such as, but not limited to its computing resources, utilization,network architecture (identification of machine where it isinstantiated, location with reference to other search heads 504 and/orsearch nodes 506, computing resources shared with other search heads 504and/or search nodes 506, such as data stores, processors, I/O, etc.),etc.

In some embodiments, based on the receipt of a particular query or arequest from a search service or a component of the query system 214,the resource monitor 508 can identify a search head to process theparticular query. In certain embodiments, the resource monitor 508 canidentify the search head based on a search head mapping policy. Thesearch head mapping policy can indicate one or more criteria foridentifying or assigning a search head 504 for a query. In some cases,the search head mapping policy can indicate that a search head 504should be assigned based on its availability, the number of concurrentsearches that it is processing/managing, resource utilization, etc. Assuch, the query system 214 can dynamically assign search heads 504 toprocess queries. In some such cases, a search head 512 can process andmanage queries associated with different tenants. By configuring thesearch head 512 to process queries associated with different tenants,the data intake and query system 108 can improve resource utilizationand decrease the amount of resource used. For example, if a search head504 is statically assigned to a tenant, then its resources may beunavailable to other tenants or other components of the data intake andquery system 108, even if the tenant is not executing any searches. Incontrast if a search head 504 is dynamically assigned to queriesassociated with different tenants then if a particular tenant is notexecuting any searches then the search head 504 that would otherwise beunused can be used to process/manage queries associated with othertenants thereby increasing the resource utilization of the data intakeand query system 108 as a whole.

As described herein, the search manager 514 and/or resource monitor 508can use the resource catalog 510 to identify search nodes 506 availableto execute a query. In some embodiments, the search manager 214 and/orresource monitor 508 can communicate with the resource catalog 510 usingan API. In some embodiments, the search manager 514 and/or resourcemonitor 508 assign search nodes 506 to execute queries based on one ormore policies, such as a search node mapping policy, etc. Similar to thedynamic assignment of search heads 504 to queries associated withdifferent tenants or data identifiers, dynamically assigning searchnodes 506 to queries can significantly improve resource utilization anddecrease compute resources used by the data intake and query system 108.

3.5. Common Storage

Returning to FIG. 2, the common storage 216 can be used to store dataindexed by the indexing system 212, and can be implemented using one ormore data stores 218.

In some systems, the same computing devices (e.g., indexers) operateboth to ingest, index, store, and search data. The use of an indexer toboth ingest and search information may be beneficial, for example,because an indexer may have ready access to information that it hasingested, and can quickly access that information for searchingpurposes. However, use of an indexer to both ingest and searchinformation may not be desirable in all instances. As an illustrativeexample, consider an instance in which ingested data is organized intobuckets, and each indexer is responsible for maintaining buckets withina data store corresponding to the indexer. Illustratively, a set of tenindexers may maintain 100 buckets, distributed evenly across ten datastores (each of which is managed by a corresponding indexer).Information may be distributed throughout the buckets according to aload-balancing mechanism used to distribute information to the indexersduring data ingestion. In an idealized scenario, information responsiveto a query would be spread across the 100 buckets, such that eachindexer may search their corresponding ten buckets in parallel, andprovide search results to a search head. However, it is expected thatthis idealized scenario may not always occur, and that there will be atleast some instances in which information responsive to a query isunevenly distributed across data stores. As one example, consider aquery in which responsive information exists within ten buckets, all ofwhich are included in a single data store associated with a singleindexer. In such an instance, a bottleneck may be created at the singleindexer, and the effects of parallelized searching across the indexersmay be minimized. To increase the speed of operation of search queriesin such cases, it may therefore be desirable to store data indexed bythe indexing system 212 in common storage 216 that can be accessible toany one or multiple components of the indexing system 212 or the querysystem 214.

Common storage 216 may correspond to any data storage system accessibleto the indexing system 212 and the query system 214. For example, commonstorage 216 may correspond to a storage area network (SAN), networkattached storage (NAS), other network-accessible storage system (e.g., ahosted storage system, such as Amazon S3 or EBS provided by Amazon,Inc., Google Cloud Storage, Microsoft Azure Storage, etc., which mayalso be referred to as “cloud” storage), or combination thereof. Thecommon storage 216 may include, for example, hard disk drives (HDDs),solid state storage devices (SSDs), or other substantially persistent ornon-transitory media. Data stores 218 within common storage 216 maycorrespond to physical data storage devices (e.g., an individual HDD) ora logical storage device, such as a grouping of physical data storagedevices or a containerized or virtualized storage device hosted by anunderlying physical storage device. In some embodiments, the commonstorage 216 may also be referred to as a shared storage system or sharedstorage environment as the data stores 218 may store data associatedwith multiple customers, tenants, etc., or across different data intakeand query systems 108 or other systems unrelated to the data intake andquery systems 108.

The common storage 216 can be configured to provide high availability,highly resilient, low loss data storage. In some cases, to provide thehigh availability, highly resilient, low loss data storage, the commonstorage 216 can store multiple copies of the data in the same anddifferent geographic locations and across different types of data stores(e.g., solid state, hard drive, tape, etc.). Further, as data isreceived at the common storage 216 it can be automatically replicatedmultiple times according to a replication factor to different datastores across the same and/or different geographic locations.

In one embodiment, common storage 216 may be multi-tiered, with eachtier providing more rapid access to information stored in that tier. Forexample, a first tier of the common storage 216 may be physicallyco-located with the indexing system 212 or the query system 214 andprovide rapid access to information of the first tier, while a secondtier may be located in a different physical location (e.g., in a hostedor “cloud” computing environment) and provide less rapid access toinformation of the second tier.

Distribution of data between tiers may be controlled by any number ofalgorithms or mechanisms. In one embodiment, a first tier may includedata generated or including timestamps within a threshold period of time(e.g., the past seven days), while a second tier or subsequent tiersincludes data older than that time period. In another embodiment, afirst tier may include a threshold amount (e.g., n terabytes) orrecently accessed data, while a second tier stores the remaining lessrecently accessed data.

In one embodiment, data within the data stores 218 is grouped intobuckets, each of which is commonly accessible to the indexing system 212and query system 214. The size of each bucket may be selected accordingto the computational resources of the common storage 216 or the dataintake and query system 108 overall. For example, the size of eachbucket may be selected to enable an individual bucket to be relativelyquickly transmitted via a network, without introducing excessiveadditional data storage requirements due to metadata or other overheadassociated with an individual bucket. In one embodiment, each bucket is750 megabytes in size. Further, as mentioned, in some embodiments, somebuckets can be merged to create larger buckets.

As described herein, each bucket can include one or more files, such as,but not limited to, one or more compressed or uncompressed raw machinedata files, metadata files, filter files, indexes files, bucket summaryor manifest files, etc. In addition, each bucket can store eventsincluding raw machine data associated with a timestamp.

As described herein, the indexing nodes 404 can generate buckets duringindexing and communicate with common storage 216 to store the buckets.For example, data may be provided to the indexing nodes 404 from one ormore ingestion buffers of the intake system 210. The indexing nodes 404can process the information and store it as buckets in common storage216, rather than in a data store maintained by an individual indexer orindexing node. Thus, the common storage 216 can render information ofthe data intake and query system 108 commonly accessible to elements ofthe system 108. As described herein, the common storage 216 can enableparallelized searching of buckets to occur independently of theoperation of indexing system 212.

As noted above, it may be beneficial in some instances to separate dataindexing and searching. Accordingly, as described herein, the searchnodes 506 of the query system 214 can search for data stored withincommon storage 216. The search nodes 506 may therefore becommunicatively attached (e.g., via a communication network) with thecommon storage 216, and be enabled to access buckets within the commonstorage 216.

Further, as described herein, because the search nodes 506 in someinstances are not statically assigned to individual data stores 218 (andthus to buckets within such a data store 218), the buckets searched byan individual search node 506 may be selected dynamically, to increasethe parallelization with which the buckets can be searched. For example,consider an instance where information is stored within 100 buckets, anda query is received at the data intake and query system 108 forinformation within ten buckets. Unlike a scenario in which buckets arestatically assigned to an indexer, which could result in a bottleneck ifthe ten relevant buckets are associated with the same indexer, the tenbuckets holding relevant information may be dynamically distributedacross multiple search nodes 506. Thus, if ten search nodes 506 areavailable to process a query, each search node 506 may be assigned toretrieve and search within one bucket greatly increasing parallelizationwhen compared to the low-parallelization scenarios (e.g., where a singleindexer 206 is required to search all ten buckets).

Moreover, because searching occurs at the search nodes 506 rather thanat the indexing system 212, indexing resources can be allocatedindependently to searching operations. For example, search nodes 506 maybe executed by a separate processor or computing device than indexingnodes 404, enabling computing resources available to search nodes 506 toscale independently of resources available to indexing nodes 404.Additionally, the impact on data ingestion and indexing due toabove-average volumes of search query requests is reduced or eliminated,and similarly, the impact of data ingestion on search query resultgeneration time also is reduced or eliminated.

As will be appreciated in view of the above description, the use of acommon storage 216 can provide many advantages within the data intakeand query system 108. Specifically, use of a common storage 216 canenable the system 108 to decouple functionality of data indexing byindexing nodes 404 with functionality of searching by search nodes 506.Moreover, because buckets containing data are accessible by each searchnode 506, a search manager 514 can dynamically allocate search nodes 506to buckets at the time of a search in order to increase parallelization.Thus, use of a common storage 216 can substantially improve the speedand efficiency of operation of the system 108.

3.6. Data Store Catalog

The data store catalog 220 can store information about the data storedin common storage 216, and can be implemented using one or more datastores. In some embodiments, the data store catalog 220 can beimplemented as a portion of the common storage 216 and/or using similardata storage techniques (e.g., local or cloud storage, multi-tieredstorage, etc.). In another implementation, the data store catalog 22—mayutilize a database, e.g., a relational database engine, such ascommercially-provided relational database services, e.g., Amazon'sAurora. In some implementations, the data store catalog 220 may use anAPI to allow access to register buckets, and to allow query system 214to access buckets. In other implementations, data store catalog 220 maybe implemented through other means, and maybe stored as part of commonstorage 216, or another type of common storage, as previously described.In various implementations, requests for buckets may include a tenantidentifier and some form of user authentication, e.g., a user accesstoken that can be authenticated by authentication service. In variousimplementations, the data store catalog 220 may store one datastructure, e.g., table, per tenant, for the buckets associated with thattenant, one data structure per partition of each tenant, etc. In otherimplementations, a single data structure, e.g., a single table, may beused for all tenants, and unique tenant IDs may be used to identifybuckets associated with the different tenants.

As described herein, the data store catalog 220 can be updated by theindexing system 212 with information about the buckets or data stored incommon storage 216. For example, the data store catalog can store anidentifier for a sets of data in common storage 216, a location of thesets of data in common storage 216, tenant or indexes associated withthe sets of data, timing information about the sets of data, etc. Inembodiments where the data in common storage 216 is stored as buckets,the data store catalog 220 can include a bucket identifier for thebuckets in common storage 216, a location of or path to the buckets incommon storage 216, a time range of the data in the bucket (e.g., rangeof time between the first-in-time event of the bucket and thelast-in-time event of the bucket), a tenant identifier identifying acustomer or computing device associated with the bucket, and/or an indexor partition associated with the bucket, etc.

In certain embodiments, the data store catalog 220 can include anindication of a location of a copy of a bucket found in one or moresearch nodes 506. For example, as buckets are copied to search nodes506, the query system 214 can update the data store catalog 220 withinformation about which search nodes 506 include a copy of the buckets.This information can be used by the query system 214 to assign searchnodes 506 to buckets as part of a query.

In certain embodiments, the data store catalog 220 can function as anindex or inverted index of the buckets stored in common storage 216. Forexample, the data store catalog 220 can provide location and otherinformation about the buckets stored in common storage 216. In someembodiments, the data store catalog 220 can provide additionalinformation about the contents of the buckets. For example, the datastore catalog 220 can provide a list of sources, sourcetypes, or hostsassociated with the data in the buckets.

In certain embodiments, the data store catalog 220 can include one ormore keywords found within the data of the buckets. In such embodiments,the data store catalog can be similar to an inverted index, exceptrather than identifying specific events associated with a particularhost, source, sourcetype, or keyword, it can identify buckets with dataassociated with the particular host, source, sourcetype, or keyword.

In some embodiments, the query system 214 (e.g., search head 504, searchmaster 512, search manager 514, etc.) can communicate with the datastore catalog 220 as part of processing and executing a query. Incertain cases, the query system 214 communicates with the data storecatalog 220 using an API. As a non-limiting example, the query system214 can provide the data store catalog 220 with at least a portion ofthe query or one or more filter criteria associated with the query. Inresponse, the data store catalog 220 can provide the query system 214with an identification of buckets that store data that satisfies atleast a portion of the query. In addition, the data store catalog 220can provide the query system 214 with an indication of the location ofthe identified buckets in common storage 216 and/or in one or more localor shared data stores of the search nodes 506.

Accordingly, using the information from the data store catalog 220, thequery system 214 can reduce (or filter) the amount of data or number ofbuckets to be searched. For example, using tenant or partitioninformation in the data store catalog 220, the query system 214 canexclude buckets associated with a tenant or a partition, respectively,that is not to be searched. Similarly, using time range information, thequery system 214 can exclude buckets that do not satisfy a time rangefrom a search. In this way, the data store catalog 220 can reduce theamount of data to be searched and decrease search times.

As mentioned, in some cases, as buckets are copied from common storage216 to search nodes 506 as part of a query, the query system 214 canupdate the data store catalog 220 with the location information of thecopy of the bucket. The query system 214 can use this information toassign search nodes 506 to buckets. For example, if the data storecatalog 220 indicates that a copy of a bucket in common storage 216 isstored in a particular search node 506, the query system 214 can assignthe particular search node to the bucket. In this way, the query system214 can reduce the likelihood that the bucket will be retrieved fromcommon storage 216. In certain embodiments, the data store catalog 220can store an indication that a bucket was recently downloaded to asearch node 506. The query system 214 for can use this information toassign search node 506 to that bucket.

3.7. Query Acceleration Data Store

With continued reference to FIG. 2, the query acceleration data store222 can be used to store query results or datasets for acceleratedaccess, and can be implemented as, a distributed in-memory databasesystem, storage subsystem, local or networked storage (e.g., cloudstorage), and so on, which can maintain (e.g., store) datasets in bothlow-latency memory (e.g., random access memory, such as volatile ornon-volatile memory) and longer-latency memory (e.g., solid statestorage, disk drives, and so on). In some embodiments, to increaseefficiency and response times, the accelerated data store 222 canmaintain particular datasets in the low-latency memory, and otherdatasets in the longer-latency memory. For example, in some embodiments,the datasets can be stored in-memory (non-limiting examples: RAM orvolatile memory) with disk spillover (non-limiting examples: hard disks,disk drive, non-volatile memory, etc.). In this way, the queryacceleration data store 222 can be used to serve interactive oriterative searches. In some cases, datasets which are determined to befrequently accessed by a user can be stored in the lower-latency memory.Similarly, datasets of less than a threshold size can be stored in thelower-latency memory.

In certain embodiments, the search manager 514 or search nodes 506 canstore query results in the query acceleration data store 222. In someembodiments, the query results can correspond to partial results fromone or more search nodes 506 or to aggregated results from all thesearch nodes 506 involved in a query or the search manager 514. In suchembodiments, the results stored in the query acceleration data store 222can be served at a later time to the search head 504, combined withadditional results obtained from a later query, transformed or furtherprocessed by the search nodes 506 or search manager 514, etc. Forexample, in some cases, such as where a query does not include atermination date, the search manager 514 can store initial results inthe acceleration data store 222 and update the initial results asadditional results are received. At any time, the initial results, oriteratively updated results can be provided to a client device 204,transformed by the search nodes 506 or search manager 514, etc.

As described herein, a user can indicate in a query that particulardatasets or results are to be stored in the query acceleration datastore 222. The query can then indicate operations to be performed on theparticular datasets. For subsequent queries directed to the particulardatasets (e.g., queries that indicate other operations for the datasetsstored in the acceleration data store 222), the search nodes 506 canobtain information directly from the query acceleration data store 222.

Additionally, since the query acceleration data store 222 can beutilized to service requests from different client devices 204, thequery acceleration data store 222 can implement access controls (e.g.,an access control list) with respect to the stored datasets. In thisway, the stored datasets can optionally be accessible only to usersassociated with requests for the datasets. Optionally, a user whoprovides a query can indicate that one or more other users areauthorized to access particular requested datasets. In this way, theother users can utilize the stored datasets, thus reducing latencyassociated with their queries.

In some cases, data from the intake system 210 (e.g., ingested databuffer 310, etc.) can be stored in the acceleration data store 222. Insuch embodiments, the data from the intake system 210 can be transformedby the search nodes 506 or combined with data in the common storage 216

Furthermore, in some cases, if the query system 214 receives a querythat includes a request to process data in the query acceleration datastore 222, as well as data in the common storage 216, the search manager514 or search nodes 506 can begin processing the data in the queryacceleration data store 222, while also obtaining and processing theother data from the common storage 216. In this way, the query system214 can rapidly provide initial results for the query, while the searchnodes 506 obtain and search the data from the common storage 216.

It will be understood that the data intake and query system 108 caninclude fewer or more components as desired. For example, in someembodiments, the system 108 does not include an acceleration data store222. Further, it will be understood that in some embodiments, thefunctionality described herein for one component can be performed byanother component. For example, the search master 512 and search manager514 can be combined as one component, etc.

3.8. Metadata Catalog

FIG. 6 is a block diagram illustrating an embodiment of a metadatacatalog 221. The metadata catalog 221 can be implemented using one ormore data stores, databases, computing devices, or the like. In someembodiments, the metadata catalog 221 is implemented using one or morerelational databases, such as, but not limited to, Dynamo DB and/orAurora DB.

As described herein, the metadata catalog 221 can store informationabout datasets and/or rules used or supported by the data intake andquery system 108. Furthermore, the metadata catalog 221 can be used to,among other things, interpret dataset identifiers in a query,verify/authenticate a user's permissions and/or authorizations fordifferent datasets, identify additional processing as part of the query,identify one or more source datasets from which to retrieve data as partof the query, determine how to extract data from datasets, identifyconfigurations/definitions/dependencies to be used by search nodes toexecute the query, etc.

In certain embodiments, the query system 214 can use the metadatacatalog 221 to dynamically determine the dataset configurations and ruleconfigurations to be used to execute the query (also referred to hereinas the query configuration parameters). In certain embodiments, thequery system 214 can use the dynamically determined query configurationparameters to provide a stateless search experience. For example, if thequery system 214 determines that search heads 504 are to be used toprocess a query or if an assigned search head 504 becomes unavailable,the query system 214 can communicate the dynamically determined queryconfiguration parameters (and query to be executed) to another searchhead 504 without data loss and/or with minimal or reduced time loss.

In the illustrated embodiment, the metadata catalog 221 stores one ormore dataset association records 602, one or more dataset configurationrecords 604, and one or more rule configuration records 606. It will beunderstood, that the metadata catalog 221 can store more or lessinformation as desired. Although shown in the illustrated embodiment asbelonging to different folders or files, it will be understood, that thevarious dataset association records 602, dataset configuration records604, and rule configuration records 606 can be stored in the same file,directory, and/or database. For example, in certain embodiments, themetadata catalog 221 can include one or more entries in a database foreach dataset association record 602, dataset (or dataset configurationrecord 604), and/or rule (or rule configuration record 606). Moreover,in certain embodiments, the dataset configuration records 604 and/or therule configuration records 606 can be included as part of the datasetassociation records 602.

In some cases, the metadata catalog 221 may not store separate datasetassociation records 602. Rather the datasets association records 602shown in FIG. 6 can be considered logical associations between one ormore dataset configuration records 604 and/or one or more ruleconfiguration records 606. In some such embodiments, the logicalassociation can be determined based on an identifier or entry of eachdataset configuration record 604 and/or rule configuration record 606.For example, the dataset configuration records 604 and ruleconfiguration records 606 that begin with “shared,” can be consideredpart of the “shared” dataset association record 602A (even if separatedata structure does not physically or logically exist on a data store)and the dataset configuration records 604 and rule configuration records606 that begin with “trafficTeam,” can be considered part of the“trafficTeam” dataset association record 602N.

In some embodiments, a user can modify the metadata catalog 221 via thegateway 215. For example, the gateway 215 can receive instruction fromclient device 204 to add/modify/delete dataset association records 602,dataset configuration records 604, and/or rule configuration records606. The information received via the gateway 215 can be used by themetadata catalog 221 to create, modify, or delete a dataset associationrecord 602, dataset configuration record 604, and/or a ruleconfiguration record 606. However, it will be understood that themetadata catalog 221 can be modified in a variety of ways and/or withoutusing the gateway 215.

In certain embodiments, the metadata catalog 221 can create, modify, ordelete a dataset association record 602, dataset configuration record604, and/or a rule configuration record 606 based on an explicitinstruction to do so from a user.

In some embodiments, the metadata catalog 221 can create, modify, ordelete a dataset association record 602, dataset configuration record604, and/or a rule configuration record 606 based on a user'sinteraction with the system 108 and/or without an explicit instruction.For example, if a user enters a query in a user interface and theninstructs the system 108 to execute the query, the metadata catalog 221can create a dataset configuration record 604 based on the query and/orcan add the query as a dataset to a dataset association record 602(depending on the module that was used or identified when the query wasexecuted). With continued reference to the example, the created datasetconfiguration record 604 can include the query and indicate that thetype of dataset is a query, saved search, or view. In addition, thecreated dataset configuration record 604 can include authorizationinformation for users that are allowed to use the query or that haveaccess to the datasets referenced by the query, the identity of the userthat entered the query, the identity of a group of users with which theuser is associated, tenant information, dependency datasets, a job IDcorresponding to the job ID created by the system 108 as part ofexecuting the query, results of the query, and/or query resultsidentifier corresponding to the query results (e.g., job ID or otheridentifier that can be used to identify the query results). More or lessinformation can be determined and added to the dataset associationrecord as desired.

Similarly, if a user enters a query, the metadata catalog 221, can editthe dataset configuration record 604. With continued reference to theexample above, if another user enters the same query or the same userexecutes the query at a later time (with or without prompting by thesystem 108), the metadata catalog 221 can edit the corresponding datasetconfiguration 604. For example, the metadata catalog 221 can increment acount for the number of times the query has been used, add informationabout the users that have used the query, include a job ID, queryresults, and/or query results identifier, each time the query isexecuted, etc.

3.8.1. Dataset Association Records

As described herein, the dataset association records 602 can indicatehow to refer to one or more datasets (e.g., provide a name or otheridentifier for the datasets), identify associations or relationshipsbetween a particular dataset and one or more rules or other datasetsand/or indicate the scope or definition of a dataset. Accordingly, adataset association record 602 can include or identify one or moredatasets 608 and/or rules 610.

In certain embodiments, a dataset association record 602 can provide amechanism to avoid conflicts in dataset and/or rule identifiers. Forexample, different dataset association records 602 can use the same nameto refer to different datasets, however, the data intake and querysystem 108 can differentiate the datasets with the same name based onthe dataset association record 602 with which the different datasets areassociated. Accordingly, in some embodiments, a dataset can beidentified using a logical identifier or name and/or a physicalidentifier or name. The logical identifier may refer to a particulardataset in the context of a particular dataset association record 602.The physical identifier may be used by the metadata catalog 221 and/orthe data intake and query system 108 to uniquely identify the datasetfrom other datasets supported or used by the data intake and querysystem 108.

In some embodiments, the data intake and query system 108 can determinea physical identifier for a dataset using an identifier of the datasetassociation record 602 with which the dataset is associated. In someembodiments, the physical name can correspond to a combination of thelogical name and the name of the dataset association record 602. Incertain embodiments, the data intake and query system 108 can determinethe physical name for a dataset by appending the name of the datasetassociation record 602 to the name of the dataset. For example, if thename of the dataset is “main” and it is associated with or part of the“shared” dataset association record 602, the data intake and querysystem 108 can generate a physical name for the dataset as “shared.main”or “shared main.” In this way, if another dataset association record 602“test” includes a “main” dataset, the “main” dataset from the “shared”dataset association record will not conflict with the “main” datasetfrom the “test” dataset association record (identified as “test.main” or“test_main”). It will be understood that a variety of ways can be usedto generate or determine a physical name for a dataset. For example, thedata intake and query system 108 can concatenate the logical name andthe name of the dataset association record 602, use a differentidentifier, etc.

In some embodiments, the dataset association records 602 can also beused to limit or restrict access to datasets and/or rules. For example,if a user uses one dataset association record 602 they may be unable toaccess or use datasets and/or rules from another dataset associationrecord 602. In some such embodiments, if a query identifies a datasetassociation record 602 for use but references datasets or rules ofanother dataset association record 602, the data intake and query system108 can indicate an error.

In certain embodiments, datasets and/or rules can be imported from onedataset association record 602 to another dataset association record602. Importing a dataset and/or rule can enable a dataset associationrecord 602 to use the referenced dataset and/or rule. In certainembodiments, when importing a dataset and/or rule 610, the importeddataset and/or rule 610 can be given a different name for use in thedataset association record 602. For example, a “main” dataset in onedataset association record can be imported to another datasetassociation record and renamed “traffic.” However, it will be understoodthat in some embodiments, the imported dataset 608 and/or rule 610 canretain the same name.

Accordingly, in some embodiments, the logical identifier for a datasetcan vary depending on the dataset association record 602 used, but thephysical identifier for the dataset may not change. For example, if the“main” dataset from the “shared” dataset association record is importedby the “test” dataset association record and renamed as “traffic,” thesame dataset may be referenced as “main” when using the “shared” datasetassociation record and may be referenced as “traffic” when using the“test” dataset association record. However, in either case, the dataintake and query system 108 can recognize that, regardless of thelogical identifier used, both datasets refer to the “shared.main”dataset.

In some embodiments, one or more datasets and/or rules can be importedautomatically. For example, consider a scenario where a rule from the“main” dataset association record 602 is imported by the “test” datasetassociation record and references dataset “users.” In such a scenario,even if the dataset “users” is not explicitly imported by the “test”dataset association record 602, the “users” dataset can be imported bythe “test” dataset association record 602. In this way, the data intakeand query system 108 can reduce the likelihood that an error occurs whenan imported dataset and/or rule references a dataset and/or rule thatwas not explicitly imported.

In certain cases, when a dataset and/or rule is automatically imported,the data intake and query system 108 can provide limited functionalitywith respect to the automatically imported dataset and/or rule. Forexample, by explicitly importing a dataset and/or rule, a user may beable to reference the dataset and/or rule in a query, whereas if thedataset and/or rule is automatically imported, a user may not be able toreference the dataset and/or rule the query. However, the data intakeand query system 108 may be able to reference the automatically importeddataset and/or rule in order to execute a query without errors.

Datasets of a dataset association record 602 can be associated with adataset type. A dataset type can be used to differentiate how tointeract with the dataset. In some embodiments, datasets of the sametype can have similar characteristics or be interacted with in a similarway. For example, index datasets and metrics interactions datasets maybe searchable, collection datasets may be searchable via a lookupdataset, view datasets may include query parameters or a query, etc.Non-limiting examples of dataset types include, but are not limited to:index (or partition), view, lookup, collections, metrics interactions,action service, interactions, four hexagonal coordinate systems, etc.

In some cases, the datasets may or may not refer to other datasets. Incertain embodiments, a dataset may refer to no other datasets, one otherdataset, or multiple datasets. A dataset that does not refer to anotherdataset may be referred to herein as a non-referential dataset, adataset that refers to one dataset may be referred to as a singlereference dataset, and a dataset that refers to multiple datasets may bereferred to as a multi-reference dataset.

In certain embodiments, some datasets can include data of the dataintake and query system 108. Some such datasets may also be referred toherein as source datasets. For example, index or partition datasets caninclude data stored in buckets as described herein. Similarly,collection datasets can include collected data. As yet another examplemetrics interactions datasets can include metrics data. In some cases, asource dataset may not refer to another dataset or otherwise identifiedas a non-referential dataset or non-referential source dataset. However,it will be understood that in certain embodiments, a source dataset canbe a single reference dataset (or single reference source dataset)and/or a multi-reference dataset (or multi-reference source dataset).

In some embodiments, certain datasets can be used to reference data in aparticular source dataset. Some such datasets may be referred to hereinas source reference datasets. For example, a source dataset may includecertain restrictions that preclude it from making its data searchablegenerally. In some such cases, a source reference dataset can be used toaccess the data of the source dataset. For example, a collection datasetmay not make its data searchable except via a lookup dataset. As such,the collection dataset may be referred to as a source dataset and thelookup dataset may be referred to as a source reference dataset. In someembodiments, a source reference dataset can correspond to or be pairedwith a particular source dataset. In certain embodiments, each sourcereference dataset references only one other (source) dataset. In suchembodiments, the source reference dataset can be referred to as a singlereference dataset or single source reference dataset. However, it willbe understood that source reference datasets can be configured in avariety of ways and/or may reference multiple datasets (and be referredto as a multi-reference dataset or multi-source reference dataset).

In certain embodiments, a dataset can include one or more queryparameters. Some such datasets may be referred to as query datasets. Forexample a view dataset can include a query that identifies a set of dataand how to process the set of data and/or one or more query parameters.When referenced, the data intake and query system 108 can incorporatethe query parameters of the query dataset into a query to beprocessed/executed by the query system 214. Similar to a query, a querydataset can reference one dataset (single reference dataset or singlereference query dataset) or multiple datasets (multi-reference datasetor multi-reference query dataset) and/or include an instruction toaccess one or more datasets (e.g., from, lookup, search, etc.).Moreover, the query dataset can include multiple query parameters toprocess the data from the one or more datasets (e.g., union, stats,count by, sort by, where, etc.)

As mentioned, in some cases, a dataset 608 in a dataset associationrecord 602 can be imported or inherited from another dataset associationrecord 602. In some such cases, if the dataset association record 602includes an imported dataset 608, it can identify the dataset 608 as animported dataset and/or it can identify the dataset 608 as having thesame dataset type as the corresponding dataset 608 from the otherdataset association record 602.

Rules of a dataset association record 602 can identify types of data andone or more actions that are to be performed on the identified types ofdata. The rule can identify the data in a variety of ways. In someembodiments, the rule can use a field-value pair, index, or othermetadata to identify data that is to be processed according to theactions of the rule. For example, a rule can indicate that the dataintake and query system 108 is to perform three processes or extractionrules on data from the “main” index dataset (or multiple or all datasetsof a dataset association record 602) with a field-value pair“sourcetype:foo.” In certain cases, a rule can apply to one or moredatasets of a dataset association record 602. In some cases, a rule canapply to all datasets of dataset association record 602. For example,the rule 610A can apply to all datasets of the shared datasetassociation record 602A or to all index type datasets of the shareddataset association record 602A, etc.

The actions of a rule can indicate a particular process that is to beapplied to the data Similar to dataset types, each action can have anaction type. Action of the same type can have a similar characteristicor perform a similar process on the data. Non-limiting examples ofaction types include regex, aliasing, auto-lookup, and calculated field.

Regex actions can indicate a particular extraction rule that is to beused to extract a particular field value from a field of the identifieddata. Auto-lookup actions can indicate a particular lookup that is totake place using data extracted from an event to identify relatedinformation stored elsewhere. For example, an auto-lookup can indicatethat when a UID value is extracted from an event, it is to be comparedwith a data collection that relates UIDs to usernames to identify theusername associated with the UID. Aliasing actions can indicate how torelate fields from different data. For example, one sourcetype mayinclude usernames in a “customer” field and another sourcetype mayinclude usernames in a “user” field. An aliasing action can associatethe two field names together or associate both field names with anotherfield name, such as “username.” Calculated field actions can indicatehow to calculate a field from data in an event. For example, acalculated field may indicate that an average is to be calculated fromthe various numbers in an event and assigned to the field name“score_avg.” It will be understood that additional actions can be usedto process or extract information from the data as desired.

In the illustrated embodiment of FIG. 6, two dataset association records602A, 602N (also referred to herein as dataset association record(s)602), two dataset configuration records 604A, 604N (also referred toherein as dataset configuration record(s) 604), and two ruleconfiguration records 606A, 606N (also referred to herein as ruleconfiguration record(s) 606) are shown. However, it will be understoodthat fewer or more dataset association records 602 dataset configurationrecords 604, and/or rule definitions 606 can be included in the metadatacatalog 221.

As mentioned, each dataset association record 602 can include a name (orother identifier) for the dataset association record 602, anidentification of one or more datasets 608 associated with the datasetassociation record 602, and one or more rules 610. As described herein,the datasets 608 of a dataset association record 602 can be native tothe dataset association record 602 or imported from another datasetassociation record 602. Similarly, rules of a dataset association record602 can be native to the dataset association record 602 and/or importedfrom another dataset association record 602.

In the illustrated embodiment, the name of the dataset associationrecord 602A is “shared” and includes the “main” dataset 608A, “metrics”dataset 608B, “users” dataset 608C, and “users-col” dataset 608D. Inaddition, the “main” dataset 608A and “metrics” dataset 608B are indexdatasets, the “users” dataset 608C is a lookup dataset associated withthe collection “users-col” dataset 608D. Moreover, in the illustratedembodiment, the “main” dataset 608A, “metrics” dataset 608B, and“users-col” dataset 608D are non-referential source datasets and the“users” dataset 608C is a source reference dataset (and single referencedataset) that references the “users-col” dataset 608D.

In addition, in the illustrated embodiment, the dataset associationrecord 602A includes the “X” rule 610A associated with the “main”dataset 608A and “metrics” dataset 608B. The “X” rule 610A uses afield-value pair “sourcetype:foo” to identify data that is to beprocessed according to an “auto lookup” action 612A, “regex” action612B, and “aliasing” action 612C. Accordingly, in some embodiments, whendata from the “main” dataset 608A is accessed, the actions 612A, 612B,612C of the “X” rule 610A are applied to data of the sourcetype “foo.”

Similar to the dataset association record 602A, the dataset associationrecord 602N includes a name (“trafficTeam”) and various native indexdatasets 608E, 608F (“main” and “metrics,” respectively), a collectiondataset 608G (“threats-col”) and a lookup dataset 608H (“threats”), anda native rule 610C (“Y”). In addition, the dataset association record602 includes a view dataset 608I (“threats-encountered”). The“threats-encountered” dataset 608I includes a query (shown in thedataset configuration record 604N) “|from traffic|lookup threats sigOUTPUT threat|where threat=*|stats count by threat” that references twoother datasets 608J, 608H (“traffic” and “threats”). Thus, when the“threats-encountered” dataset 608I is referenced, the data intake andquery system 108 can process and execute the identified query. Moreover,in the illustrated embodiment, the “main” dataset 608E, “metrics”dataset 608E, and “threats-col” dataset 608G are non-referential sourcedatasets, the “threats” dataset 608H is a single source referencedataset (source reference and single reference dataset) that referencesthe “threats-col” dataset 608G, and the “threats-encountered dataset”608I is a multi-reference query dataset.

The dataset association record 602N also includes an imported “traffic”dataset 608J and an imported “shared.X” rule 610B. In the illustratedembodiment, the “traffic” dataset 608J corresponds to the “main” dataset608A from the “shared” dataset association record 602A. As describedherein, in some embodiments, to associate the “main” dataset 608A (fromthe “shared” dataset association record 602A) with the “traffic” dataset608J (from the “trafficTeam” dataset association record 602N), the nameof the dataset association record 602A (“shared”) is placed in front ofthe name of the dataset 608A (“main”) However, it will be understoodthat a variety of ways can be used to associate a dataset 608 from onedataset association record 602 with the dataset 608 from another datasetassociation record 602. As described herein, by importing the dataset“main” dataset 608A, a user using the dataset association record 602 andcan reference the “main” dataset 608A and/or access the data in the“main” dataset 608A.

Similar to the “main” dataset 608A, the “X” rule 610A is also importedby the “trafficTeam” dataset association record 602N as the “shared.X”rule 610B. As described herein, by importing “X” rule 610A, a user usingthe “trafficTeam” dataset association record 602N can use the “X” rule610A. Furthermore, in some embodiments, if the “X” rule 610A (or adataset) references other datasets, such as, the “users” dataset 608Cand the “users-col” dataset 608D, these datasets can be automaticallyimported by the “trafficTeam” dataset association record 602N. However,a user may not be able to reference these automatically imported rules(datasets) in a query.

3.8.2. Dataset Configuration Records

The dataset configuration records 604 can include the configurationand/or access information for the datasets associated with the datasetassociation records 602 or otherwise used or supported by the dataintake and query system 108. In certain embodiments, the metadatacatalog 221 includes the dataset configuration records 604 for all ofthe datasets 608 used or supported by the data intake and query system108 in one or more files or entries. In some embodiments, the metadatacatalog 221 includes a separate file, record, or entry for each dataset608 or dataset configuration record 604.

The dataset configuration record 604 for each dataset 608 can identify aphysical and/or logical name for the dataset, a dataset type,authorization information indicating users or credentials that have toaccess the dataset, access information (e.g., IP address, end point,indexer information), and/or location information (e.g., physicallocation of data) to enable access to the data of the dataset, etc.Furthermore, depending on the dataset type, each dataset configurationrecord 604 can indicate custom fields or characteristics associated withthe dataset. In some embodiments, index, metrics, lookup, and collectiondatasets may include location information, while view datasets do not.For example, in some cases view datasets may not have data except thatwhich is access via an index, metrics, lookup, and collection datasets.Accordingly, the content and information for the dataset associationrecords 602 can vary depending on the dataset type.

In the illustrated embodiment, the “shared.main” dataset configurationrecord 604A for the “shared.main” dataset 608A indicates that it is anindex data type, and includes authorization information indicating theentities that have access to the “shared.main” dataset 608A, accessinformation that enables the data intake and query system 108 to accessthe data of the “shared.main” dataset 608A, and location informationthat indicates the location where the data is located. In some cases,the location information and access information can overlap or becombined. In addition, the dataset configuration record 604A includes aretention period indicating the length of time in which data associatedwith the “shared.main” dataset 608A is to be retained by the data intakeand query system 108. In some embodiments, because “shared.main” isimported into the “trafficTeam” dataset association record 602N as thedataset “traffic,” it may also be identified as the“trafficTeam.traffic” dataset 608J. Accordingly, in some suchembodiments, the dataset configuration record 604A may include anadditional identifier for “trafficTeam.traffic” or as is shown in theillustrated embodiment, it may indicate that the “trafficTeam.traffic”dataset is a dependent dataset.

Similarly, in the illustrated embodiment, the“trafficTeam.threats-encountered” dataset configuration record 604N forthe “trafficTeam.threats-encountered” dataset 608I indicates that it isa view type of dataset and includes authorization information indicatingthe entities that have access to it. In addition, the datasetconfiguration record 604N includes the query for the“trafficTeam.threats-encountered” dataset 608I.

The dataset configuration record 604 can also include additionalinformation or metadata (also referred to herein as annotations). Theannotations can correspond to user annotations added by a user or tosystem annotations that are automatically generated by the system.

In the illustrated embodiment of FIG. 6, the dataset configurationrecord 604A includes a system annotation 614 that indicates the numberof identified fields of the “shared.main” dataset (4), a systemannotations 616 that identify the fields of the “shared.main” dataset(sig, IP_addr, userID, error), and a system annotation 618 thatidentifies the datasets that depend on the “shared.main” dataset(“trafficTeam.traffic” and “trafficTeam.threats-encountered”). In theillustrated embodiment, the dependent datasets annotation 618 includesreference to the “trafficTeam.traffic” dataset 608J even though it isonly an identifier to import the “shared.main” dataset to the datasetassociation record 602N. However, in some embodiments, datasets thatonly import another dataset or are merely identifiers for anotherdataset may not be identified as dependent datasets and/or may not beincluded as part of a system annotation.

With further reference to the illustrated embodiment of FIG. 6, thedataset configuration record 604N includes a user annotation 620 thatidentifies a group associated with the dataset“trafficTeam.threats-encountered” 608I (also referred to herein as“threats-encountered”). This annotation can be used by the system todetermine which group is responsible for the dataset 602N and/or shouldbe charged for its use. The dataset configuration record 604N alsoincludes a system annotation 622 that identifies the datasets on whichthe “threats-encountered” dataset depends (“trafficTeam.traffic,” whichis also “shared.main” and “trafficTeam.threats”), and a systemannotation 624 that identifies the number of times the“threats-encountered” dataset 608I has been used and/or accessed. Insome embodiments, because trafficTeam.traffic merely imports“shared.main” it may not be considered a related dataset or may beomitted from the dependency dataset annotation 622.

In some embodiments, the data intake and query system 108 (e.g., thequery system 214) creates a job ID each time a query is run or executed(e.g., each time a dataset is used or accessed). The job ID mayreference a specific query run at a specific time, or in reference to aspecific time, and point to results of the query. The data intake andquery system 108 (e.g., the query system 214) can store the job ID in adataset configuration record that includes the query that is run. Ingeneral, a dataset configuration record associated with a dataset thatis of the type “savedsearch/view” or any other type on which a query canbe run includes at least one job ID once the query included in datasetconfiguration record is run at least once. For example, the queryincluded in a dataset configuration record can be run one or more times.The dataset configuration record can include the job ID for the mostrecent query that is run, the job ID for the first query that is run,the job IDs for some, but not all, of the queries that are run, the jobIDs for all of the queries that are run, and/or any combination thereof.With further reference to the illustrated embodiment of FIG. 6, thesystem annotation 624 indicates that the“trafficTeam.threats-encountered” dataset 608I has been used and/oraccessed 30 times. Thus, the query included in the dataset configurationrecord 604N may have been run 30 times. In the illustrated embodiment,the dataset configuration record 604N includes a system annotation 626that identifies a job ID (“F341A5”) of the most recent query that is runon the “trafficTeam.threats-encountered” dataset 608I. In otherembodiments not illustrated, however, the dataset configuration record604N can include a system annotation 626 that identifies the job ID ofthe first query that is run on the “trafficTeam.threats-encountered”dataset 608I, job IDs of some, but not all, of the queries run on the“trafficTeam.threats-encountered” dataset 608I, job IDs of all of thequeries run on the “trafficTeam.threats-encountered” dataset 608I,and/or any combination thereof.

In some embodiments, the data intake and query system 108 (e.g., thequery system 214) includes in a dataset configuration record not onlysome or all of the job IDs of a query that is run or executed, but alsothe results of each executed query that has a job ID present in thedataset configuration record. With further reference to the illustratedembodiment of FIG. 6, the dataset configuration record 604N includes asystem annotation 628 that identifies the results of the queryassociated with the job ID identified by the system annotation 626(“F341A5”). For example, the most recent results of running the datasetconfiguration record 604N query on the “trafficTeam.threats-encountered”dataset 608I can be a count of 2 for “threat1,” a count of 5 for“threat2,” and so on. In other embodiments not illustrated, the datasetconfiguration record 604N can include the query result of the firstquery that is run on the “trafficTeam.threats-encountered” dataset 608I,the query results of some, but not all, of the queries that are run onthe “trafficTeam.threats-encountered” dataset 608I, the query results ofall of the queries that are run on the “trafficTeam.threats-encountered”dataset 608I, and/or any combination thereof. For example, if thedataset configuration record 604N includes one or more systemannotations 626 identifying multiple job IDs, then the datasetconfiguration record 604N may also include one or more systemannotations 628 identifying the results of each job ID identified by thesystem annotation(s) 626. The query results can be represented in a JSONformat, as a table, or in some other format, as desired.

In addition to the job ID and query results, a dataset configurationrecord can store additional information related to a query, such as, butnot limited to, the user that executed a query, the tenant associatedwith the query, the time the query was executed, or the time the job IDwas created, etc. The system 108 can use this information to generatestatistical information about different queries and/or providerecommendations to users. For example, the system 108 can provide queryrecommendations based on the most frequently used queries generally orby the user, or users from the same tenant, users with similaradministrative privileges or access controls, etc.

It will be understood that fewer or more annotations can be included inthe dataset configuration record 604N. For example, the datasetconfiguration record 604N can include the identity and number of fieldsused by the “threats-encountered” dataset.

It will be understood that more or less information or annotations canbe included in each dataset configuration record 604. For example, thedataset configuration records 604 can indicate whether the dataset is anon-referential, single reference or multi-reference dataset and/oridentify any datasets that it references (by the physical or logicalidentifier of the datasets or other mechanism), is dependent on or thatdepend on it, its usage, etc. As another example, the datasetconfiguration records 604 can identify one or more rules associated withthe dataset. Additional information regarding example annotations thatcan be generated and/or included in dataset configuration records 604 orin the metadata catalog 221 are described herein.

Although not illustrated in FIG. 6, it will be understood that themetadata catalog 221 can include a separate dataset configuration record604 for the datasets 608B, 608C, 608D, 608E, 608F, 608G, 608H, and 608J.Furthermore, it will be understood that the metadata catalog 221 caninclude data from multiple tenants. In some cases, the data (e.g.,dataset association records, dataset configuration records, and/or ruleconfiguration records, etc.) from different tenants can be logicallyand/or physically segregated within the metadata catalog 221.

In some embodiments, some datasets may not have a separate datasetconfiguration record 604. For example, imported datasets and/or viewdatasets may not include a separate dataset configuration record 604. Incertain embodiments, view datasets can include a query identified in adataset association record 602, but may not have a separate datasetconfiguration record 604 like index, metrics, collection, and/or lookupdatasets.

In some embodiments, the dataset configuration record 604 for the“traffic” dataset 608J (or other imported datasets) can indicate thatthe “traffic” dataset 608J is an imported version of the “shared.main”dataset 608A. In certain cases, the dataset configuration record 604 forthe “traffic” dataset 608J can include a reference to the datasetconfiguration record 604 for the “shared.main” dataset 608A and/or caninclude all of the configuration information for the “shared.main”dataset 608A. In certain embodiments, the metadata catalog 221 may omita separate dataset configuration record 604 for the “traffic” dataset608J because that dataset is an imported dataset of the “main” dataset608A from the “share” dataset association record 602A.

As described herein, although the dataset association records 602A, 602Neach include a “main” dataset 608B, 608E and a “metrics” dataset 608B,608F, the data intake and query system 108 can differentiate between thedatasets from the different dataset association records based on thedataset association record 602 associated with the datasets. Forexample, the metadata catalog 221 can include separate datasetconfiguration records 604 for the “shared.main” dataset 608A,“trafficTeam.main” dataset 608E, “shared.metrics” dataset 608B, and the“trafficTeam.metrics” dataset 608F.

3.8.3. Rule Configuration Records

The rule configuration records 606 can include the rules, actions, andinstructions for executing the rules and actions for the rulesreferenced of the dataset association records 602 or otherwise used orsupported by the data intake and query system 108. In some embodiments,the metadata catalog 221 includes a separate file or entry for each ruleconfiguration record 606. In certain embodiments, the metadata catalog221 includes the rule configuration records 606 for all of the rules 610in one or more files or entries.

In the illustrated embodiment, a rule configuration records 606N isshown for the “shared.X” rule 610A. The rule configuration record 606Ncan include the specific parameters and instructions for the “shared.X”rule 610A. For example, the rule configuration record 606N can identifythe data that satisfies the rule (sourcetype:foo of the “main” dataset608A). In addition, the rule configuration record 606N can include thespecific parameters and instructions for the actions associated with therule. For example, for the “regex” action 612B, the rule configurationrecord 606N can indicate how to parse data with a sourcetype “foo” toidentify a field value for a “customerID” field, etc. With continuedreference to the example, for the “aliasing” action 612C, the ruleconfiguration record 606N can indicate that the “customerID” fieldcorresponds to a “userNumber” field in data with a sourcetype “roo.”Similarly, for the “auto-lookup” action 612A, the rule configurationrecord 606N can indicate that the field value for the “customerID” fieldcan be used to lookup a customer name using the “users” dataset 608C and“users-col” dataset 608D.

It will be understood that more or less information can be included ineach rule configuration record 606. For example, the rule configurationrecords 606 can identify the datasets or dataset association records 602to which the rule applies, indicate whether a rule is imported, indicateinclude authorizations and/or access information to use the rule, etc.

Similar to the dataset configuration records 604, the metadata catalog221 can include rule configuration records 606 for the various rules 610of the dataset association record 602 or other rules supported for useby the data intake and query system 108. For example, the metadatacatalog 221 can include rule configuration record 606 for the “shared.X”rule 610A and the “trafficTeam.Y” rule 610C.

As described herein, the dataset association records 602, datasetconfiguration records 604, and/or rule configuration records 606 can beused by the system 108 to interpret dataset identifiers in a query,verify/authenticate a user's permissions and/or authorizations fordifferent datasets, identify additional processing as part of the query,identify one or more source datasets from which to retrieve data as partof the query, determine how to extract data from datasets, identifyconfigurations/definitions/dependencies to be used by search nodes toexecute the query, etc.

In certain embodiments, the dataset association records 602, datasetconfiguration records 604, and/or rule configuration records 606 can beused to identify primary datasets and secondary datasets. The primarydatasets can include datasets that are to be used to execute the query.The secondary datasets can correspond to datasets that are directly orindirectly referenced by the query but are not used to execute thequery. Similarly, the dataset association records 602, datasetconfiguration records 604, and/or rule configuration records 606 can beused to identify rules (or primary rules) that are to be used to executethe query.

3.8.4. Annotations

In some embodiments, the system 108 stores data without type or asunstructured data. Thus, the system 108 may not “know” or have insight(e.g., include a table or other stored information) into the content ofthe data. For example, the system 108 may not have any insight into whatfields (e.g., IP address, error code, userID, etc.) can be found inwhich datasets or what rules are related to what datasets. While it maybe advantageous for a variety of reasons to store data without type oras unstructured data and use late binding schema to query the data, thiscan result in longer query times and the use of greater processingresources during query processing and execution. To decrease query timesand/or processing resources used during a query, the system 108 candynamically add information or metadata (also referred to herein asannotations) to the metadata catalog as it is learned.

In some embodiments, the annotations can be added to the datasetconfiguration records 604, the rule configuration records 606 or as aseparate annotation entry in the metadata catalog 221, or elsewhere inthe system 108. For example, as changes are made to the metadata catalog221 or as queries are executed on the data, the system 108 can inferinformation or learn about the datasets and rules and update the datasetconfiguration records 604 and rule configuration records 606 with thisinformation. In the illustrated embodiment of FIG. 6, dynamicallygenerated annotations 614, 616, 618, 622, 624 are included as part ofthe dataset configuration records 604A, 604N. However, as mentioned, theannotations can be stored as a separate entry or data structure. Forexample, the system 108 can update or create an annotation entry foreach annotation and store the annotations in a database, such as arelational database or table of the metadata catalog 221, or elsewherein the system 108. When stored in a separate data structure, theannotations can identify any datasets or fields to which they areassociated or related.

The updated datasets configuration records 604 (or annotation entries)can be used by the system 108 to propagate annotations to relateddatasets, protect datasets from deletion, improve portability, and makerecommendations to a user and/or process additional queries as they arereceived, etc. In this way, the system 108 can provide an incrementallyevolving schema or map of the data and can enable more efficient queriesand/or reduce the amount of processing resources used during queryexecution.

3.8.4.1. Generating Annotations

In some cases, the annotations can be added to the metadata catalog 221(in dataset configuration records 604 or as annotation entries) manuallyby a user or automatically by the system 108.

It will be understood that a user can manually add a variety ofannotations (also referred to herein as “user annotations”) to themetadata catalog 221, which can be used by the system 108 to dynamicallymake user recommendations, improve query processing, and/or search time.For example, a user can add or revise a dataset configuration record 604to the metadata catalog 221 for a dataset. As part of adding/revisingthe dataset configuration record, the user can add annotations about thecapabilities of the dataset source associated with the dataset (e.g.,speed, bandwidth, parallelization, size, etc.), one or more fields ofthe dataset and one or more relationships between the fields, one ormore datasets related to the new/revised dataset, users or groupsassociated with the dataset, units or preferred units for data from thedataset, etc.

In certain embodiments, the annotations can be added automatically bythe system 108 in response to monitoring system use and/or based ondetected changes to the metadata catalog 221 (also referred to herein as“system annotations”). To generate the various system annotations, thesystem 108 can use one or more processes, threads, containers, isolatedexecution environments, etc. (generically referred to as processes). Insome cases, the system 108 can use multiple processes to generate systemannotations. For example, a separate process can be used to generateannotations based on parsing a query, monitoring query execution,monitoring user/groups, monitoring applications, etc. Similarly,separate processes can be used to generate annotations based on detectedchanges to the metadata catalog 221. For example, separate processes canbe used to generate annotations in response to detecting the addition orremoval of a field, dataset, unit or preferred unit, field-datasetrelationship, inter-field relationship, inter-dataset relationship, etc.

Moreover, the various processes can communicate with each other togenerate the system annotations. For example, consider the scenariowhere one process is used to generate annotations based on parsing aquery and another process is used to generate annotations based on theidentification of a new field or new field-dataset relationship in themetadata catalog 221. If the process that parses the query identifiesand generates an annotation based on a new field for a dataset, it canalert the process that generates annotations based on new fields addedto the dataset. In this way, the system 108 can effectively increase itsknowledge or understanding of the data stored thereon, and use thisunderstanding to facilitate more effective searching of the data.

3.8.4.1.1. System Annotations Based on System Use

A variety of system annotations can be generated based on monitoringsystem use. As non-limiting examples, system annotations can beautomatically added to the metadata catalog 221 in response to parsing aquery, executing a query, tracking user interactions with the system108, tracking the use of different applications executing in the system108, or other system use monitoring, etc.

The system annotations generated based on monitoring system use can beused for a variety of functions. For example, the system annotationsgenerated based on monitoring system use can be used to track field use,dataset use, suggest fields or datasets to a user (e.g.,frequently/infrequently used fields or datasets, related fields ordatasets, similar fields or datasets, datasets that satisfy the criteriaof another dataset, such as datasets that satisfy the field criteria ofa view dataset, etc.), display similar datasets, suggest applications,identify groups or individuals responsible for the use of a particulardataset (e.g., determine charge back distribution), cost-basedoptimizations (e.g., when querying data from multiple datasets, how toprioritize which dataset to obtain first), propagate annotations torelated datasets or fields, etc.

3.8.4.1.1.1. QUERY PARSING

In some cases, the system 108 can parse and extract metadata fromqueries to generate system annotations. The queries can correspond toqueries entered by a user in a user interface or queries that form partof a dataset, such as a view dataset.

In some embodiments, the system 108 can use the syntax and semantics ofa query to extract metadata from the query. For example, based on theknown syntax of a query processing language, the system 108 can identifyquery commands and locations where information can be extracted, such asdataset names or identifiers, field names or identifiers, etc. Based onthe syntax and semantics of the query, the system 108 can identifyrelationships between the datasets and fields of the query. Furthermore,the system 108 can iteratively parse the identified datasets to identifyadditional datasets, fields, relationships, etc. For example, the system108 can use the dataset identifiers to identify and parse thecorresponding dataset configuration records 604 to identify additionaldatasets, fields, and/or rules.

As a non-limiting example, with reference to the query “|fromtraffic|lookup threats sig OUTPUT threat|where threat=*|stats count bythreat” of the “threats-encountered” dataset 602N, the system 108 can,based on a knowledge of the commands for the query language used,determine that “from,” “lookup,” “OUTPUT,” “where,” “stats,” and “countby” are query commands. In addition, the system 108 can, based on theknown syntax or semantics of the query language, determine that thewords following the “from,” and “lookup” commands are dataset names oridentifiers and the words following “where,” “stats,” “count by,” and“OUTPUT” are field names or identifiers. Similarly, the system 108 candetermine that the second word following the “lookup” command is a fieldname or identifier. Accordingly, the system 108 can determine that the“threats-encountered” dataset 602N references datasets“trafficTeam.traffic” and “trafficTeam.threats” and fields “threat” and“sig.” In addition, based on the dataset association records 602 or adataset configuration record 604, the system 108 can determine that“trafficTeam.traffic” is the “shared.main” dataset imported from thedataset association record 602A.

In addition to identifying the identity of datasets and fields of thequery, the system 108 can extract other metadata from the query, suchas, but not limited to, field-dataset relationships, inter-datasetrelationships, inter-field relationships, etc. In certain embodiments,the system 108 can identify relationships between the fields anddatasets of the query. For example, based on the presence and placementof the field names “sig” and “threat” in the query, the system 108 candetermine that the dataset “trafficTeam.traffic” (and “shared.main”)includes a field “sig,” and the dataset “trafficTeam.threats” includesthe fields “sig” and “threat.”

In some embodiments, the system 108 can determine inter-fieldrelationships. For example, given that the field “sig” is included inboth “trafficTeam.traffic” and “trafficTeam.threats,” the system 108 candetermine that there is a relationship between “sig” in“trafficTeam.traffic” (or “shared.main”) and “sig” in“trafficTeam.threats” (e.g., that the two “sigs” correspond to eachother).

Moreover, in some cases, the system 108 can determine inter-datasetrelationships. In some embodiments, based on the presence of the“trafficTeam.traffic” and “trafficTeam.threats” datasets in the query ofthe “threats-encountered” dataset 602N, the system 108 can determinethat the “threats-encountered” dataset 602N is related to and dependenton the “trafficTeam.traffic” and “trafficTeam.threats” datasets. Forexample, if the datasets “traffic” and “threats” do not exist or are notdefined, the “threats-encountered” dataset may return an error or beunable to function properly. In addition, the system 108 can identify arelationship between the “traffic” and “threats” datasets. For example,given that the “traffic” and “threats” datasets both have the same field“sig,” the system 108 can identify a foreign key relationship betweenthem—similar to the inter-field relationship discussed above.

As additional datasets are identified, the system 108 can parse thecorresponding dataset configuration records 604 to identify additionalrelationships. For example, the system 108 can determine that the“trafficTeam.threats” dataset is dependent on a“trafficTeam.threats-col” dataset, and that the “trafficTeam.traffic”(or “shared.main” dataset) is related to a rule “X,” which is dependenton dataset “shared.users,” which in turn depends on a dataset“shared.users-col.” Accordingly, the system 108 can iteratively parsethe dataset configurations to determine the relationships between thevarious rules and datasets of the system 108. Another non-limitingexample of parsing a query and extracting information about the datasetsand rules referenced by the query is given with reference to FIG. 10.

Based on the extracted metadata of the query (e.g., identity of fieldsand datasets, field-dataset relationships, inter-field relationships,inter-dataset relationships, etc.), the system 108 can generate one ormore annotations. In some embodiments, the system 108 can generate anannotation for each piece of extracted metadata and/or each identifiedrelationship. In certain embodiments, the system 108 can generate one ormore annotations for any one or any combination of the identified fieldsand datasets, the identified field-dataset relationships, the identifiedinter-field relationships, and/or the identified inter-datasetrelationships, etc.

As described herein, the annotations generated from the extractedmetadata of the query can be used to track field use, dataset use,suggest fields or datasets to a user (e.g., frequently/infrequently usedfields or datasets, related fields or datasets, similar fields ordatasets, datasets that satisfy the criteria of another dataset, such asdatasets that satisfy the field criteria of a view dataset, etc.),display similar datasets, suggest applications, identify groups orindividuals responsible for the use of a particular dataset (e.g.,determine charge back distribution), propagate annotations to relateddatasets or fields, etc.

3.8.4.1.1.2. Query Execution

In some embodiments, the system 108 can monitor system use during queryexecution. For example, during query execution, the system 108 can trackwhich dataset is being accessed, the amount of data of the dataset beingretrieved from a dataset source (e.g., the total number of data entriesbeing retrieved, the number of data entries by field that are retrieved,the total amount of data being retrieved, etc.), the amount ofprocessing resources used to retrieve data from the dataset source, theamount of time taken to obtain the data from the dataset source, thespeed at which data is retrieved from the dataset source, whether adataset source supports parallelization (e.g., whether the system 108can extract data from the dataset source in parallel or serially), etc.

Based on the information that is tracked during query execution, thesystem 108 can generate one or more annotations. For example, based onthe information, the system 108 can generate or update annotations aboutthe speed and size of a dataset or dataset source (e.g., the number ofdata entries in the dataset, the number of data entries for each knownfield of the dataset, total size of the dataset or dataset source,etc.), the connectivity or latency with a dataset source, etc. In someembodiments, the system 108 can generate an annotation for eachstatistic that is monitored or generate an annotation for a group or allof the statistics being tracked. As described herein, the annotationscan be stored as part of a dataset configuration record 604 or otherannotation entry.

The annotations generated based on monitoring the system 108 duringquery execution can be used to track the speed and size of datasets andthe capabilities of dataset sources. The system 108 can further use thisinformation to generate cost-based optimizations during query execution.Consider the scenario where a query indicates that data from dataset Aand dataset B are to be joined. The system 108 can use the annotationsgenerated from monitoring the system 108 during query execution todetermine which dataset to access first. For example, the annotationsmay indicate that for field 1, dataset A has significantly more dataentries or is slower than dataset B. Thus, if the query includes a joinof field 1, the system 108 can access dataset B first and use theinformation from dataset B to refine the data that is requested fromdataset A. As another example, if another query indicates that field 2of datasets A and B are to be used for a join and the annotationsindicate that dataset B has significantly more data entries than datasetA, the system 108 can pull data from dataset A first and use it torefine the query for dataset B. Furthermore, the system 108 can use acombination of annotations to determine which dataset to access first.For example, if dataset B has significantly more data for field 3 thandataset A, but dataset A is significantly slower, the system 108 maydetermine that it will take less time and be more efficient to pull datafrom dataset B first and use that to refine the query for dataset A.

3.8.4.1.1.3. User Monitoring

In some embodiments, the system 108 can monitor users as they interactwith the system 108. For example, the system 108 can monitor which usersuse the system 108, the duration of use, the frequency of use, whichdatasets are created, accessed, modified, or used by the user, whichapplications are used by the user, typical fields that are used by theuser, etc. Similarly, if a user is part of a group, the system 108 canmonitor the collective actions of the users of the group. Thisinformation can be used to generate user/group annotations. As describedherein, the annotations can be stored as part of a dataset configurationrecord 604 or other annotation entry.

The system 108 can use the user/group annotations to track usage of thesystem 108 by user or group. Furthermore, the system 108 can use theuser/group annotations to suggest fields, datasets, applications, etc.to the user or the group. For example, the system 108 can identifyfields or datasets that are related to or similar to fields or datasetstypically used by the user. As another example, if users with similarcharacteristics to the current user use certain fields, applications, ordatasets, the system 108 can recommend these fields, application, ordatasets to the user, etc. In this way, the system 108 can improve theusers understanding of the data in the system 108 and enhance the user'sability to user or query data in the system.

3.8.4.1.1.4. Application Monitoring

In certain embodiments, the system can monitor applications used on thesystem 108. For example, the system 108 can monitor which applicationsare available on the system 108, which datasets or dataset sources areused by the application, the frequency of use of applications, anidentification of applications that are frequently used together, anidentity of users or user types that use particular applications, etc.This information can be used to generate annotations.

The system 108 can use the annotations generated by monitoringapplications to track the usage of the applications and to makesuggestions to users. For example, if multiple users of a groupfrequently use one or more applications, the system 108 can recommendthe applications to other users of the group. As another example, if oneuser of a group begins using and spends significant time on oneapplication compared to time spent on other applications beforebeginning use of the “new” application, the system 108 can recommend the“new” application to other members of the group. In this way, the system108 can propagate knowledge about the system 108 and applications tovarious users and improve their understanding of the system 108 and howto use it effectively.

3.8.4.1.2. System Annotations Based on Changes to the Metadata Catalog

As mentioned, in some embodiments, system 108 annotations can be addedautomatically to the metadata catalog 221 in response to changes in themetadata catalog 221. The changes may be the result of a manual changeby a user, such as a user annotation, or an automated change by thesystem 108, such as a system 108 annotation. For example, when a useradds or revises information about a first dataset, the system 108 cancompare information about the first dataset with other information ofother datasets to identify potential relationships or similarities. If arelationship or similarity is detected, the system 108 can add anannotation to the dataset configuration record 604 (or annotation entry)of the first dataset as well as to the dataset configuration records 604of the other identified datasets. As another example, if the system 108updates information for the first dataset based on a query, the system108 can identify other datasets that are related to the first datasetand update metadata of the other identified datasets. In this way, asthe system 108 is used, it can learn about the datasets, and use theinformation to improve search time or search capabilities. As describedherein, in some cases, the system 108 can use one or more processes toidentify the change to the metadata catalog 221 and generate additionalannotations based on the change.

In some embodiments, based on the addition of a dataset, the system 108can identify fields of the dataset, related datasets (datasets on whichthe dataset depends), similar datasets (e.g., datasets with similarfields), dataset to which the new dataset can be mapped (e.g., viewdatasets to which the new dataset can be mapped), etc. In certainembodiments, if the added dataset is a view dataset that includes aquery, the system 108 can process the query as described above togenerate one or more annotations.

In certain embodiments, based on the addition of a field-datasetrelationship annotation or the identification of a field of a dataset,the system 108 can determine a total number of fields of the dataset,identify similar datasets and/or datasets to which the dataset can bemapped, and generate corresponding annotations. For example, based onthe addition of the field “userID” to the dataset “Logons,” the system108 can identify other datasets with a “userID” field. If found, thesystem 108 can generate an annotation for the dataset “Logons” and/orthe other dataset to indicate a similar field is located in eachdataset. As another example, based on the addition of the field “userID”to the dataset “Logons,” the system 108 can identify view datasets thatuse the field “userID” to generate a view or interface. If the viewdataset uses additional fields that are also found in the “Logons”dataset, the system 108 can generate an annotation for the dataset“Logons” and/or the other dataset to indicate that the view dataset maybe related or usable with the “Logons” dataset or that the “Logon”dataset may be mapped to the view dataset.

In certain embodiments, based on the addition of an inter-fieldrelationship or inter-dataset annotation, the system 108 can identifyadditional inter-field and inter-dataset relationships. For example ifdataset A is dependent on dataset B and dataset B is dependent ondataset C, the system 108 can determine that dataset A is dependent ondataset B and generate an additional inter-dataset annotation indicatingA's dependency on C. As another example, if field “userID” of dataset Bis related to field “ID” of dataset C and a new relationship betweenfield “ID” of dataset C and field “UID” of dataset D, the system 108 candetermine that “userID” of dataset B is related to “UID” of dataset D.

In addition, based on the addition of an inter-dataset annotation, thesystem 108 can propagate one or more annotations. For example, if analarm threshold, unit, or preferred unit is associated with a metricsdataset A and an inter-dataset relationship annotation is added thatrelates metrics dataset A with metrics dataset B, the system 108 canpropagate the alarm threshold, unit, and/or preferred unit to metricsdataset B. Specifically, if an annotation for metric cpu_speed ofdataset A indicates that the units are Hz and the preferred units areGHz, the system 108 can propagate the Hz and GHz units/preferred unitsto a corresponding cpu_speed metric of dataset B Similarly, if a datacategory annotation for a dataset or field of a dataset indicates thatthe information is confidential, then based on an inter-fieldrelationship that indicates another field is derived from theconfidential field or an inter-dataset relationship that indicatesanother dataset uses the confidential information, the system 108 canpropagate the data category annotation to the related field or dataset.

In some embodiments, based on the addition of an inter-datasetannotation, the system 108 can generate an annotation indicating thatthe dataset that is depended on should not be deleted so long as thedependent dataset exists or an annotation indicating that if the datasetthat is depended on is deleted then the dependent dataset should also bedeleted. The system can also use an inter-dataset annotation to generatean annotation that indicates the total number (and identity) of datasetsthat depend on a particular dataset, or the total number (and identity)of datasets on which the particular dataset depends.

In certain embodiments, based on an update to the field use for a field,the system 108 can compare the field use of the field with the field useof other fields and determine the popularity of the fields. Based on thepopularity, the system 108 can generate one or more annotationsindicating the popularity of the fields. Similarly, the system 108 canuse the dataset use and application use to generate annotationsindicating the popularity of different datasets and applications,respectively. In addition, using the user or group information, thesystem 108 can determine the popularity of fields, datasets, and/orapplications for a particular user or group.

In certain embodiments, based on a change/addition of a unit orpreferred unit for a dataset, the system 108 can identify relateddatasets and generate annotations for the units and preferred units forthe related datasets. Similarly, the system 108 can generate annotationsfor one or more datasets or fields in response to change/additions ofalarm thresholds or data category (e.g., use restrictions) annotationsto a related dataset or field.

3.8.4.2. Example Annotations

As mentioned, the metadata catalog 221 can include annotations orinformation about the datasets, fields, users, or applications of thesystem 108 and can be revised as additional information is learned.Non-limiting examples of annotations that can be added to the datasetconfiguration records 604, other configurations, annotation tables orentries, or other locations of the metadata catalog 221 or system 108,include but are not limited to, the identification and use of fields ina dataset, number of fields in a dataset, related fields, relateddatasets, number (and identity) of dependent datasets, number (andidentity) of datasets depended on, capabilities of a dataset or relateddataset source or provider, the identification of datasets with similarconfigurations or fields, units or preferred units of data obtained froma dataset, alarm thresholds, data categories (e.g., restrictions), usersor groups, applications, popular field, datasets, and applications (intotal or by user or group), etc. In certain cases, the annotations canbe added as the system 108 monitors system use (e.g., processingqueries, monitoring query execution, user interaction, etc.) or as thesystem 108 detects changes to the metadata catalog 221 (e.g., onemanual/automated change can lead to another automated change), etc.

3.8.4.2.1. Field Annotations

The metadata catalog 221 can store various annotations about the fieldsfound in datasets. For example, the metadata catalog 221 can include anidentification of the dataset associated with a field (or field-datasetrelationship), the number of fields of a dataset (or field count), anidentification of all fields of a dataset, the frequency of use of thedifferent fields, users of the field, etc. As described herein, theinformation about the fields of a dataset can be stored as part of adataset configuration record 604 or as part of a separate datastructure. When stored as a separate data structure, the data structurecan identify the datasets that include the field or are otherwiseassociated with or related to the field.

The number and identity of fields of a dataset can be identified in avariety of ways. In some cases, a user can manually include or add afield to the metadata catalog 221 (e.g., the dataset configurationrecord 604 or an annotation entry). For example, the user may add orrelate a regex rule to a dataset. The regex rule can define how toextract field values for the field from the dataset. Based on theinformation in the regex rule, the system 108 can identify the field andincrement the number of fields associated with the dataset.

In some embodiments, the system 108 can parse a query to identify fieldsof a dataset. As described herein, in parsing the query, the system 108can identify phrases or use the syntax of the query to identify (andcount the number of) fields. For example, with reference to the query“|from traffic|lookup threats sig OUTPUT threat|where threat=*|statscount by threat.” of threats-encountered dataset 602N, the system 108can, based on the query language used, identify “from” and “lookup” ascommands and determine that the words after “from” and “lookup,”respectively, identify a dataset and the words after “threats” and“OUTPUT,” respectively, identify a field. Accordingly, the system 108can infer that the dataset “traffic” has a field “sig” and a dataset“threats” has fields “sig” and “threat.” In some embodiments, based onthis inference, the system 108 can update the dataset configurationrecord 604 of the dataset “traffic” or generate a field-datasetrelationship annotation in the metadata catalog 221 with fieldinformation that identifies “sig” as a field associated with dataset“traffic.” Similarly, the system 108 can update the metadata catalog 221with a field-dataset annotation that identifies “sig” and “threat” asfields of the dataset “threats.” Additionally, the system 108 canidentify other fields in a query based on the syntax of the query. Witheach new field, the system 108 can update the corresponding datasetconfiguration record 604 and/or update a table that stores fieldinformation of fields in the system 108.

As queries are executed or the fields are used, the system 108 canfurther revise the dataset configuration records 604 or field entries toreflect the use of the fields over time. In this way, the system 108 cantrack the fields in the system 108, the relationship of the fields todatasets, and the frequency of use of the fields.

The system 108 can use the metadata related to the fields for a varietyof functions. In some cases, the system 108 can use the metadata relatedto the fields to make field recommendations to a user, identify datasetswith similar fields, suggest datasets for use together, identifydatasets with a particular field, etc.

In some embodiments, as a user is typing a query related to a dataset,the system 108 can use the identified fields of the dataset to indicateto the user which fields are known about that dataset. In this way, thesystem 108 can provide insight into the content of a dataset as the userenters a query. Moreover, based on information of which fields are usedmost frequently, the system 108 can recommend or more prominentlydisplay a field to the user. For example, if the system 108 hasdetermined (and the dataset configuration record 604 indicates) that thedataset “main” has at least three fields: “userID,” “IP address,” and“errorCode,” then as the user is typing out the query “from main groupby . . . ” the system 108 can display “userID,” “IP address,” and“errorCode.” Furthermore, if the system 108 has determined that “userID”is the most frequently used field (in total, by the user, or by a groupassociated with the user) related to “main” and/or most frequently usedafter “group by,” then the system 108 can suggest “userID” first orplace it more prominently relative to the other fields. In this way, thesystem 108 can aid the user in crafting a query for the system 108 toexecute based on information that the system 108 has iteratively learnedabout the data.

In certain cases, the system 108 can use the annotations related to thefields to identify datasets with similar fields and suggest use ofdatasets for views for queries. For example, if a first dataset withfields: “userID,” “productID,” and “viewTime,” is used to generate aview (or mapped to a view dataset), the system 108 can use the datasetconfiguration records 604 to compare the fields of the first datasetwith fields of other datasets. If a second dataset is identified thatincludes the fields “userID,” “productID,” and “viewTime,” the system108 can recommend the second dataset to the user for viewing and/orannotate the dataset configuration records 604 of the first and seconddataset to indicate the existence of another dataset with similarfields. As another example, if a first dataset is a view dataset thatuses the fields “userID,” “productID,” and “viewTime” from a seconddataset to generate a view or UI, the system 108 can identify otherdatasets with the fields “userID,” “productID,” and “viewTime,” andsuggest the identified datasets to the user of the view dataset. In thisway, the system 108 can track similar datasets and identify potentiallyrelated datasets.

In some cases, a user may want to execute a query using a particularfield. As the user enters a field identifier, the system 108 can suggestor identify datasets that include the particular field. In this way, thesystem 108 can aid the user in understanding the content of the databased on information that the system has iteratively learned about thedata.

In certain embodiments, the system 108 can use the number of fields toestimate a size of a particular dataset.

3.8.4.2.2. Inter-Field Relationship Annotations

The metadata catalog 221 can store information about relationshipsbetween fields of datasets. In certain embodiments, the relationshipscan correspond to one field being derived from another field, fieldswith matching, corresponding, or correlating field values, etc. Asdescribed herein, annotations about the relationship between fields ofdatasets can be stored as part of a dataset configuration record 604 oras part of a separate data structure. When stored as a separate datastructure, the data structure can identify the datasets that include thefield or are otherwise associated with or related to the field.

In some cases, when storing the inter-field relationship annotations,the system 108 can store an ID for the relationship (e.g., name orunique name for the relationship), identifiers for the datasetsassociated with the related fields, and identifiers for the fields ofthe datasets that are related. In addition, the system 108 can store arelationship type. In some embodiments, the relationship type may be anexact relationship, such that field values of the different fields match(e.g., the field value for a “UID” field of one dataset matches thefield value for an “ID” field of another dataset). In certainembodiments, the relationship type may be correlated, such as a fieldvalue of “time” in one dataset that is the most recent in time andbefore a field value of “_time” in another dataset. In some embodiments,the relationship type may be a complex relationship, such as thecombination of field values from multiple fields in one dataset to onefield value of one field in another dataset.

The relationships between fields can be identified in a variety of ways.In some cases, a user can manually include or add an inter-fieldrelationship annotation to the metadata catalog 221 (e.g., the datasetconfiguration record 604 or an annotation entry).

In some embodiments, the system 108 can parse a query or dataset toidentify relationships between fields Similar to the identification offields described herein, the system 108 can use the syntax of the queryto identify relationships between fields. For example, with continuedreference to the query of the threats-encountered dataset 602N, based onthe identification of a “sig” field in the datasets “traffic” and“threats,” the system 108 can determine that there is a relationship orforeign-key relationship between the “sig” field of “traffic” and the“sig” field of “threats.” In some such cases, based on the existence ofthe “sig” field in both datasets and its use in the same query, thesystem 108 can determine that field values in the “sig” field of“traffic” match the field values in the “sig” field of “threats.” Assuch, the system 108 can identify and store information about therelationship in the metadata catalog 221.

As another example, based on a query or parsing a dataset, the system108 can identify fields derived from other fields. For example, a querymay initially refer to a field “salary.” Field values of the field“salary,” may be transformed and/or combined with other data as part ofthe query and later referenced as the field “sum.” In some such cases,by parsing the syntax of the query, the system 108 can identify therelationship between “sum” and “salary” and identify “sum” as a fieldderived from “salary.” As such, the system 108 can identify and storeinformation about the relationship in the metadata catalog 221.

In certain embodiments, the system 108 can identify inter-fieldrelationships based on changes to the metadata catalog 221. For exampleif the metadata catalog 221 identifies a relationship between fields Aand B (e.g., field B is derived from field A) and a new inter-fieldrelationship annotation is added indicating a relationship betweenfields B and C (e.g., field C is derived from field B), the system 108can determine and generate an inter-field relationship annotation forfields A and C (e.g., field C is derived from field A).

The system 108 can use the inter-field relationship annotations topropagate additional annotations. With continued reference to the “sum”and “salary” field example above, if the “salary” field is indented aspersonally identifiable information or is otherwise subject torestrictions, the system 108 can use the relationship information toalso mark the “sum” field as PII or restricted. As another example, ifunits or preferred units are identified for one field, the system 108can use the identification of related fields to automatically identifyunits or preferred units for the field. By iteratively learning andstoring information about relationships between fields, the system 108can iteratively learn about the various connections between fields andimprove compliance with data restrictions.

3.8.4.2.3. Inter-Dataset Relationship Annotations

The metadata catalog 221 can store annotations about relationshipsbetween datasets. In some embodiments, a dataset configuration record604 of a first dataset can include the number and/or identification ofrelated datasets, such as datasets that depend on the first dataset ordatasets on which the first dataset depends. For example, if a firstdataset refers to or uses data from a second dataset, the datasetconfiguration record 604 of the first dataset and the second dataset canidentify the first dataset as being dependent on the second dataset. Incertain embodiments, certain metrics data may be identified as beingrelated to certain raw machine data datasets. As such the datasetconfiguration records 604 of the metrics data and raw machine datadatasets can identify each other as being related. As described herein,in some cases, fields of different datasets may be related or correspondto each other. As such, based on the relationship between the fields,the metadata catalog 221 can identify the datasets as being related. Asdescribed herein, annotations about the relationship between fields ofdatasets can be stored as part of a dataset configuration record 604 oras part of a separate data structure. When stored as a separate datastructure, the data structure can identify the datasets that include thefield or are otherwise associated with or related to the field.

The relationships between datasets can be identified in a variety ofways. In some cases, a user can manually include or add a relationshipbetween datasets to a dataset configuration record 604 and/or anannotation entry.

In certain embodiments, the system 108 can parse a query or dataset toidentify relationships between datasets. For example, with continuedreference to the threat-encountered dataset 602N, the system 108 canparse the query “|from traffic|lookup threats sig OUTPUT threat|wherethreat=*|stats count by threat.” In parsing the query, the system 108can use the syntax of the query language to identify datasets andrelationships. For example, “from” and “lookup” can be commands andwords following those commands can identify datasets. Accordingly, thesystem 108 can identify the datasets “trafficTeam.traffic” (which is the“shared.main” dataset imported from dataset association record 602A) and“trafficTeam.threats” from the query. Furthermore, the system 108 candetermine that the threats-encountered dataset 602N is dependent on the“trafficTeam.traffic” and “trafficTeam.threats” datasets given thatthose datasets are used in the threats-encountered query. In otherwords, without the datasets “trafficTeam.traffic” and“trafficTeam.threats,” the “threats-encountered” dataset would notfunction properly or would return an error.

In addition, the system 108 can identify a relationship between the“trafficTeam.traffic” and “trafficTeam.threats” datasets. For example,given that the “trafficTeam.traffic” and “trafficTeam.threats” datasetsboth have the same field “sig,” the system 108 can identify a foreignkey relationship between them and store a correspondingannotation—similar to the inter-field relationship field annotation.

In certain embodiments, the system 108 can identify inter-datasetrelationships based on changes to the metadata catalog 221. For example,if the metadata catalog 221 identifies a relationship between dataset Aand B (non-limiting examples: (1) dataset B depends from dataset A, (2)dataset A can be mapped to dataset B, (3) dataset A and B have similarfields) and a new inter-field relationship annotation is addedindicating a relationship between datasets B and C (non-limitingexamples: (1) dataset C depends from dataset B, (2) dataset C can bemapped to dataset B, (3) dataset B can be mapped to dataset C), thesystem 108 can determine and generate an inter-dataset relationshipannotation for datasets A and C (non-limiting examples: (1) dataset Cdepends from dataset A, (2) dataset A and C have similar fields, (3)dataset A can be mapped to dataset C).

The inter-dataset relationship annotations can be used for a variety offunctions. In some cases, the system 108 can use the inter-datasetrelationship annotations to generate additional annotations (e.g.,additional inter-dataset relationships as described above), to propagateannotations from one dataset to another dataset (e.g., if units orpreferred units are identified for dataset one then the units orpreferred units may also be used for related dataset two), to lockdatasets from or identify datasets for deletion (e.g., if dataset onedepends on dataset two then dataset two should not be deleted or ifdataset one depends on dataset two and dataset two is to be deleted thendataset one should also be deleted).

In certain embodiments, the system 108 can use the inter-datasetrelationship annotations to propagate annotations from one dataset toanother. For example, if dataset one is annotated as containingrestricted information, the system 108 can use the inter-datasetrelationship annotations to identify and annotate other datasets thatdepend from dataset one. As another example, if data from one dataset isannotated with a particular unit or preferred unit (e.g., MB instead ofbytes), the system 108 can use the inter-dataset relationshipannotations to identify other datasets that can be similarly annotated.Similarly, alarm thresholds for one dataset may be propagated to relateddatasets, etc.

3.8.4.2.4. Dataset Properties Annotations

The metadata catalog 221 can store annotations about the properties of adataset, such as, but not limited to, an (estimated) size of a dataset,the usage of the dataset, and/or the capabilities of the dataset ordataset source. In some embodiments as users interact with the datasets,the system 108 can track when a dataset is used, the frequency of itsuse, the users or groups that use the dataset, etc. In addition, as adataset is used, the metadata catalog 221 can estimate its size as itlearns about the number of fields in the dataset and/or track the amountof data obtained from the dataset. In some cases, as data is extractedfrom datasets or dataset sources, the system 108 can monitor theperformance of the dataset or dataset source. For example, the system108 can monitor the speed of the dataset source, its bandwidth, networkconnectivity, etc. Based on this information, the system 108 candetermine a cost to access a particular dataset. The cost may refer totime, computing resources, etc. This information can be stored as anannotation entry or as part of a dataset configuration record 604 asdescribed herein.

Using the usage annotations, the system 108 can make recommendations toa user. For example, based on the frequency of use of dataset one or thenumber of datasets that refer to or depend from dataset one, the system108 can recommend that dataset one be used for a particular query by theuser.

Using the estimated size, speed, cost, or capability of a dataset, thesystem 108 can allocate resources for a query that depends on thedataset. For example, the system 108 can allocate more resources if itdetermines that the dataset is relatively large, slow, or supportsparallelization, or allocate fewer resources if it determines that thedataset is relatively small or fast or does not support parallelization,etc. In addition, the system 108 can use the capabilities of the datasetto perform cost-based optimizations. For example, if, based on a query,the system 108 is to join data from dataset A and dataset B, based onthe size, speed, etc. of the datasets, the system 108 can determinewhich dataset to access first. If, for example, dataset A is smaller orfaster than dataset B, the system 108 can determine that dataset Ashould be accessed first and the results of dataset A can be used torefine the query to dataset B.

3.8.4.2.5. Normalization Annotations

The metadata catalog 221 can store normalization annotations about thedatasets. In some cases, datasets may not be explicitly related, but mayinclude similar data or fields. In some such cases, the system 108 cananalyze the datasets to identify similar datasets or dataset thatinclude similar data or fields.

In some cases, the metadata catalog 221 can identify similar datasets bycomparing fields of datasets. As field annotations are added to themetadata catalog 221, as described herein, the system 108 can comparethe fields of one dataset with the fields of another dataset. If athreshold number of fields are the same, then the system 108 cangenerate a normalization annotation (or inter-dataset relationshipannotation) indicating that the datasets include similar data. Thethreshold number can be based on the total number of fields in one orboth datasets or the number of fields used in another dataset, such as aview dataset.

In certain embodiments, as datasets are added, such as a view datasetthat references dataset 1, the fields used by the view dataset can becompared with the fields of other datasets in the metadata catalog 221.If dataset 2 includes the same or similar fields to those used by theview dataset from dataset 1, the system 108 can generate a normalizationannotation (or inter-dataset relationship annotation) indicating thesimilarity of dataset 2 to dataset 1 and/or indicate that dataset 2could be used with the view dataset.

The normalization annotations can be used by the system 108 to makesuggestions to a user about which datasets can be used with otherdatasets, such as view datasets, or to suggest that a user review adataset. For example, as a user views an interface resulting frommultiple fields from dataset 1 being mapped to a view dataset, thesystem 108 can recommend to the user that dataset 2 may provideadditional results that may be helpful to the user's analysis of dataset1.

3.8.4.2.6. Unit Annotations

The metadata catalog 221 can store unit annotations about the datasetsor fields of the datasets. In some cases, the system 108 can identifythe unit annotations based on user input and/or based on analysis ofrelated datasets. In certain embodiments, a user can indicate that datafrom a particular dataset or field has a particular unit and/or has apreferred unit. For example, a user can indicate that the unit for aparticular metric is Hz and/or that the preferred unit for the metric isMHz or GHz. The unit and/or preferred unit can be stored by the system108 as a unit annotation. As described herein, the unit annotation canbe stored as part of a dataset configuration record 604 and/orannotation entry.

In some embodiments, the system 108 can determine unit annotations basedon changes to the metadata catalog 221. For example, if datasets A and B(or a field or metric of dataset A and B) are related and a newannotation is added indicating a preferred unit for dataset A (or ametric or field of dataset A), the system 108 can automaticallydetermine and generate an annotation for dataset B (or a metric or fieldof dataset B) indicating the same preferred unit.

The unit annotations can be used by the system 108 to convert and/ordisplay the data in a particular way. For example, if the unitannotation for a field or metric is identified as a byte and thepreferred unit is a gigabyte, the system 108 can convert the bytes fromthe dataset to gigabytes and display the data as a gigabyte.Furthermore, the system 108 can propagate a unit annotation from onedataset to other datasets. In certain embodiments, the system 108 canidentify fields or datasets related to the annotated field or datasetand propagate the unit annotation to the identified field or dataset.

3.8.4.2.7. Alarm Threshold Annotations

The metadata catalog 221 can store alarm threshold annotations about thedatasets or fields of the datasets. In some cases, the system 108 canidentify the alarm threshold annotations based on user input or based onprevious user actions. For example, a user can indicate that when aparticular metric or value satisfies a threshold, a person should bealerted or an alarm sounded.

In some embodiments, the system 108 can determine alarm thresholdannotations based on changes to the metadata catalog 221. For example,if datasets A and B (or a field or metric of dataset A and B) arerelated and a new annotation is added indicating an alarm threshold fordataset A (or a metric or field of dataset A), the system 108 canautomatically determine and generate an annotation for dataset B (or ametric or field of dataset B) indicating the same alarm threshold.

The alarm threshold annotations can be used by the system 108 togenerate alarms or automatically execute a query. For example, based onan alarm threshold being satisfied, the system 108 can execute a querythat surfaces information related to the alarm threshold. In addition,the system 108 can propagate the alarm thresholds to related datasets orfields.

3.8.4.2.8. Data Category Annotations

The metadata catalog 221 can store data category annotations about thedatasets or fields of the datasets. In some cases, the system 108 canidentify the data category (or use restriction) annotations based onuser input. For example, a user can indicate that a particular field ordataset includes personally identifiable information, should beseparately tracked or monitored, etc. Based on the identification, thesystem 108 can store a data category annotation for that field ordataset.

In some embodiments, the system 108 can determine data categoryannotations based on changes to the metadata catalog 221. For example,if datasets A and B (or a field or metric of dataset A and B) arerelated and a new annotation is added indicating a data category fordataset A (or a metric or field of dataset A), the system 108 canautomatically determine and generate an annotation for dataset B (or ametric or field of dataset B) indicating the same data category. Forinstance, consider a scenario where dataset A includes a“social_security_num” field and a data category annotation indicatingthat the field is PII, and dataset B includes an “ID” field. If themetadata catalog is updated to reflect that the “ID” field is derivedfrom the “social_security_num” field, then the system can automaticallypropagate the data category for the “social_security_num” field to the“ID” field.

The data category annotations can be used by the system 108 to track howcertain data is being used and/or for compliance purposes. For example,the system can monitor PII data and generate alerts if it is notproperly stored or processed.

3.8.4.2.9. User/Group Annotations

The metadata catalog 221 can store user or group annotations. In somecases, the system 108 can identify the user/group annotations based onuser input. For example, a user can indicate that a particular user orgroup is associated with a particular dataset. In certain embodiments,the system 108 can generate the user/group annotations based on usageinformation. For example, the system 108 can track which datasets areaccessed by which users or groups of users. This information can bestored as user/group annotations. As yet another example, if aparticular user or group is the most frequent user of a dataset, thesystem 108 can relate the user or group to the dataset and generate auser/group annotation.

The user/group annotations can be used by the system 108 to determinehow usage time should be allocated between parties. For example, iftwenty users have access to a dataset, the system 108 can track which ofthe users or groups used the dataset most frequently and should becharged for the usage.

3.8.4.2.10. Application Annotations

The metadata catalog 221 can store application annotations. In certainembodiments, the system 108 can generate the application annotationsbased on usage information. For example, the system 108 can track whichapplications are used by which users and with what datasets. Thisinformation can be stored as application annotations as part of adataset configuration record 604 or annotation entry.

The application annotations can be used by the system 108 to makerecommendations to users. For example, if a threshold number of usersfrequently use three applications and a different user frequently usestwo of the three applications, the system 108 can recommend the thirdapplication to the user.

4.0. Data Intake and Query System Functions

As described herein, the various components of the data intake and querysystem 108 can perform a variety of functions associated with theintake, indexing, storage, and querying of data from a variety ofsources. It will be understood that any one or any combination of thefunctions described herein can be combined as part of a single routineor method. For example, a routine can include any one or any combinationof one or more data ingestion functions, one or more indexing functions,and/or one or more searching functions.

4.1. Intake

As discussed above, ingestion into the data intake and query system 108can be facilitated by an intake system 210, which functions to processdata according to a streaming data model, and make the data available asmessages on an output ingestion buffer 310, categorized according to anumber of potential topics. Messages may be published to the outputingestion buffer 310 by a streaming data processors 308, based onpreliminary processing of messages published to an intake ingestionbuffer 306. The intake ingestion buffer 306 is, in turn, populated withmessages by one or more publishers, each of which may represent anintake point for the data intake and query system 108. The publishersmay collectively implement a data retrieval subsystem 304 for the dataintake and query system 108, which subsystem 304 functions to retrievedata from a data source 202 and publish the data in the form of amessage on the intake ingestion buffer 306. A flow diagram depicting anillustrative embodiment for processing data at the intake system 210 isshown at FIG. 7. While the flow diagram is illustratively described withrespect to a single message, the same or similar interactions may beused to process multiple messages at the intake system 210.

4.1.1. Publication to Intake Topic(s)

As shown in FIG. 7, processing of data at the intake system 210 canillustratively begin at (1), where a data retrieval subsystem 304 or adata source 202 publishes a message to a topic at the intake ingestionbuffer 306. Generally described, the data retrieval subsystem 304 mayinclude either or both push-based and pull-based publishers. Push-basedpublishers can illustratively correspond to publishers whichindependently initiate transmission of messages to the intake ingestionbuffer 306. Pull-based publishes can illustratively correspond topublishers which await an inquiry by the intake ingestion buffer 306 formessages to be published to the buffer 306. The publication of a messageat (1) is intended to include publication under either push- orpull-based models.

As discussed above, the data retrieval subsystem 304 may generate themessage based on data received from a forwarder 302 and/or from one ormore data sources 202. In some instances, generation of a message mayinclude converting a format of the data into a format suitable forpublishing on the intake ingestion buffer 306. Generation of a messagemay further include determining a topic for the message. In oneembodiment, the data retrieval subsystem 304 selects a topic based on adata source 202 from which the data is received, or based on thespecific publisher (e.g., intake point) on which the message isgenerated. For example, each data source 202 or specific publisher maybe associated with a particular topic on the intake ingestion buffer 306to which corresponding messages are published. In some instances, thesame source data may be used to generate multiple messages to the intakeingestion buffer 306 (e.g., associated with different topics).

4.1.2. Transmission to Streaming Data Processors

After receiving a message from a publisher, the intake ingestion buffer306, at (2), determines subscribers to the topic. For the purposes ofexample, it will be associated that at least one device of the streamingdata processors 308 has subscribed to the topic (e.g., by previouslytransmitting to the intake ingestion buffer 306 a subscription request).As noted above, the streaming data processors 308 may be implemented bya number of (logically or physically) distinct devices. As such, thestreaming data processors 308, at (2), may operate to determine whichdevices of the streaming data processors 308 have subscribed to thetopic (or topics) to which the message was published.

Thereafter, at (3), the intake ingestion buffer 306 publishes themessage to the streaming data processors 308 in accordance with thepub-sub model. This publication may correspond to a “push” model ofcommunication, whereby an ingestion buffer determines topic subscribersand initiates transmission of messages within the topic to thesubscribers. While interactions of FIG. 7 are described with referenceto such a push model, in some embodiments, a pull model of transmissionmay additionally or alternatively be used. Illustratively, rather thanan ingestion buffer determining topic subscribers and initiatingtransmission of messages for the topic to a subscriber (e.g., thestreaming data processors 308), an ingestion buffer may enable asubscriber to query for unread messages for a topic, and for thesubscriber to initiate transmission of the messages from the ingestionbuffer to the subscriber. Thus, an ingestion buffer (e.g., the intakeingestion buffer 306) may enable subscribers to “pull” messages from thebuffer. As such, interactions of FIG. 7 (e.g., including interactions(2) and (3) as well as (9), (10), (16), and (17) described below) may bemodified to include pull-based interactions (e.g., whereby a subscriberqueries for unread messages and retrieves the messages from anappropriate ingestion buffer).

4.1.3. Messages Processing

On receiving a message, the streaming data processors 308, at (4),analyze the message to determine one or more rules applicable to themessage. As noted above, rules maintained at the streaming dataprocessors 308 can generally include selection criteria indicatingmessages to which the rule applies. This selection criteria may beformatted in the same manner or similarly to extraction rules, discussedin more detail below, and may include any number or combination ofcriteria based on the data included within a message or metadata of themessage, such as regular expressions based on the data or metadata.

On determining that a rule is applicable to the message, the streamingdata processors 308 can apply to the message one or more processingsub-rules indicated within the rule. Processing sub-rules may includemodifying data or metadata of the message. Illustratively, processingsub-rules may edit or normalize data of the message (e.g., to convert aformat of the data) or inject additional information into the message(e.g., retrieved based on the data of the message). For example, aprocessing sub-rule may specify that the data of the message betransformed according to a transformation algorithmically specifiedwithin the sub-rule. Thus, at (5), the streaming data processors 308applies the sub-rule to transform the data of the message.

In addition or alternatively, processing sub-rules can specify adestination of the message after the message is processed at thestreaming data processors 308. The destination may include, for example,a specific ingestion buffer (e.g., intake ingestion buffer 306, outputingestion buffer 310, etc.) to which the message should be published, aswell as the topic on the ingestion buffer to which the message should bepublished. For example, a particular rule may state that messagesincluding metrics within a first format (e.g., imperial units) shouldhave their data transformed into a second format (e.g., metric units)and be republished to the intake ingestion buffer 306. At such, at (6),the streaming data processors 308 can determine a target ingestionbuffer and topic for the transformed message based on the ruledetermined to apply to the message. Thereafter, the streaming dataprocessors 308 publishes the message to the destination buffer andtopic.

For the purposes of illustration, the interactions of FIG. 7 assumethat, during an initial processing of a message, the streaming dataprocessors 308 determines (e.g., according to a rule of the dataprocessor) that the message should be republished to the intakeingestion buffer 306, as shown at (7). The streaming data processors 308further acknowledges the initial message to the intake ingestion buffer306, at (8), thus indicating to the intake ingestion buffer 306 that thestreaming data processors 308 has processed the initial message orpublished it to an intake ingestion buffer. The intake ingestion buffer306 may be configured to maintain a message until all subscribers haveacknowledged receipt of the message. Thus, transmission of theacknowledgement at (8) may enable the intake ingestion buffer 306 todelete the initial message.

It is assumed for the purposes of these illustrative interactions thatat least one device implementing the streaming data processors 308 hassubscribed to the topic to which the transformed message is published.Thus, the streaming data processors 308 is expected to again receive themessage (e.g., as previously transformed the streaming data processors308), determine whether any rules apply to the message, and process themessage in accordance with one or more applicable rules. In this manner,interactions (2) through (8) may occur repeatedly, as designated in FIG.7 by the iterative processing loop 402. By use of iterative processing,the streaming data processors 308 may be configured to progressivelytransform or enrich messages obtained at data sources 202. Moreover,because each rule may specify only a portion of the total transformationor enrichment of a message, rules may be created without knowledge ofthe entire transformation. For example, a first rule may be provided bya first system to transform a message according to the knowledge of thatsystem (e.g., transforming an error code into an error descriptor),while a second rule may process the message according to thetransformation (e.g., by detecting that the error descriptor satisfiesalert criteria). Thus, the streaming data processors 308 enable highlygranulized processing of data without requiring an individual entity(e.g., user or system) to have knowledge of all permutations ortransformations of the data.

After completion of the iterative processing loop 402, the interactionsof FIG. 7 proceed to interaction (9), where the intake ingestion buffer306 again determines subscribers of the message. The intake ingestionbuffer 306, at (10), the transmits the message to the streaming dataprocessors 308, and the streaming data processors 308 again analyze themessage for applicable rules, process the message according to therules, determine a target ingestion buffer and topic for the processedmessage, and acknowledge the message to the intake ingestion buffer 306,at interactions (11), (12), (13), and (15). These interactions aresimilar to interactions (4), (5), (6), and (8) discussed above, andtherefore will not be re-described. However, in contrast to interaction(13), the streaming data processors 308 may determine that a targetingestion buffer for the message is the output ingestion buffer 310.Thus, the streaming data processors 308, at (14), publishes the messageto the output ingestion buffer 310, making the data of the messageavailable to a downstream system.

FIG. 7 illustrates one processing path for data at the streaming dataprocessors 308. However, other processing paths may occur according toembodiments of the present disclosure. For example, in some instances, arule applicable to an initially published message on the intakeingestion buffer 306 may cause the streaming data processors 308 topublish the message out ingestion buffer 310 on first processing thedata of the message, without entering the iterative processing loop 402.Thus, interactions (2) through (8) may be omitted.

In other instances, a single message published to the intake ingestionbuffer 306 may spawn multiple processing paths at the streaming dataprocessors 308. Illustratively, the streaming data processors 308 may beconfigured to maintain a set of rules, and to independently apply to amessage all rules applicable to the message. Each application of a rulemay spawn an independent processing path, and potentially a new messagefor publication to a relevant ingestion buffer. In other instances, thestreaming data processors 308 may maintain a ranking of rules to beapplied to messages, and may be configured to process only a highestranked rule which applies to the message. Thus, a single message on theintake ingestion buffer 306 may result in a single message or multiplemessages published by the streaming data processors 308, according tothe configuration of the streaming data processors 308 in applyingrules.

As noted above, the rules applied by the streaming data processors 308may vary during operation of those processors 308. For example, therules may be updated as user queries are received (e.g., to identifymessages whose data is relevant to those queries). In some instances,rules of the streaming data processors 308 may be altered during theprocessing of a message, and thus the interactions of FIG. 7 may bealtered dynamically during operation of the streaming data processors308.

While the rules above are described as making various illustrativealterations to messages, various other alterations are possible withinthe present disclosure. For example, rules in some instances be used toremove data from messages, or to alter the structure of the messages toconform to the format requirements of a downstream system or component.Removal of information may be beneficial, for example, where themessages include private, personal, or confidential information which isunneeded or should not be made available by a downstream system. In someinstances, removal of information may include replacement of theinformation with a less confidential value. For example, a mailingaddress may be considered confidential information, whereas a postalcode may not be. Thus, a rule may be implemented at the streaming dataprocessors 308 to replace mailing addresses with a corresponding postalcode, to ensure confidentiality. Various other alterations will beapparent in view of the present disclosure.

4.1.4. Transmission to Subscribers

As discussed above, the rules applied by the streaming data processors308 may eventually cause a message containing data from a data source202 to be published to a topic on an output ingestion buffer 310, whichtopic may be specified, for example, by the rule applied by thestreaming data processors 308. The output ingestion buffer 310 maythereafter make the message available to downstream systems orcomponents. These downstream systems or components are generallyreferred to herein as “subscribers.” For example, the indexing system212 may subscribe to an indexing topic 342, the query system 214 maysubscribe to a search results topic 348, a client device 102 maysubscribe to a custom topic 352A, etc. In accordance with the pub-submodel, the output ingestion buffer 310 may transmit each messagepublished to a topic to each subscriber of that topic, and resilientlystore the messages until acknowledged by each subscriber (or potentiallyuntil an error is logged with respect to a subscriber). As noted above,other models of communication are possible and contemplated within thepresent disclosure. For example, rather than subscribing to a topic onthe output ingestion buffer 310 and allowing the output ingestion buffer310 to initiate transmission of messages to the subscriber 702, theoutput ingestion buffer 310 may be configured to allow a subscriber 702to query the buffer 310 for messages (e.g., unread messages, newmessages since last transmission, etc.), and to initiate transmission ofthose messages form the buffer 310 to the subscriber 702. In someinstances, such querying may remove the need for the subscriber 702 toseparately “subscribe” to the topic.

Accordingly, at (16), after receiving a message to a topic, the outputingestion buffer 310 determines the subscribers to the topic (e.g.,based on prior subscription requests transmitted to the output ingestionbuffer 310). At (17), the output ingestion buffer 310 transmits themessage to a subscriber 702. Thereafter, the subscriber may process themessage at (18). Illustrative examples of such processing are describedbelow, and may include (for example) preparation of search results for aclient device 204, indexing of the data at the indexing system 212, andthe like. After processing, the subscriber can acknowledge the messageto the output ingestion buffer 310, thus confirming that the message hasbeen processed at the subscriber.

4.1.5. Data Resiliency and Security

In accordance with embodiments of the present disclosure, theinteractions of FIG. 7 may be ordered such that resiliency is maintainedat the intake system 210. Specifically, as disclosed above, datastreaming systems (which may be used to implement ingestion buffers) mayimplement a variety of techniques to ensure the resiliency of messagesstored at such systems, absent systematic or catastrophic failures.Thus, the interactions of FIG. 7 may be ordered such that data from adata source 202 is expected or guaranteed to be included in at least onemessage on an ingestion system until confirmation is received that thedata is no longer required.

For example, as shown in FIG. 7, interaction (8)—wherein the streamingdata processors 308 acknowledges receipt of an initial message at theintake ingestion buffer 306—can illustratively occur after interaction(7)—wherein the streaming data processors 308 republishes the data tothe intake ingestion buffer 306. Similarly, interaction (15)—wherein thestreaming data processors 308 acknowledges receipt of an initial messageat the intake ingestion buffer 306—can illustratively occur afterinteraction (14)—wherein the streaming data processors 308 republishesthe data to the intake ingestion buffer 306. This ordering ofinteractions can ensure, for example, that the data being processed bythe streaming data processors 308 is, during that processing, alwaysstored at the ingestion buffer 306 in at least one message. Because aningestion buffer 306 can be configured to maintain and potentiallyresend messages until acknowledgement is received from each subscriber,this ordering of interactions can ensure that, should a device of thestreaming data processors 308 fail during processing, another deviceimplementing the streaming data processors 308 can later obtain the dataand continue the processing.

Similarly, as shown in FIG. 7, each subscriber 702 may be configured toacknowledge a message to the output ingestion buffer 310 afterprocessing for the message is completed. In this manner, should asubscriber 702 fail after receiving a message but prior to completingprocessing of the message, the processing of the subscriber 702 can berestarted to successfully process the message. Thus, the interactions ofFIG. 7 can maintain resiliency of data on the intake system 108commensurate with the resiliency provided by an individual ingestionbuffer 306.

While message acknowledgement is described herein as an illustrativemechanism to ensure data resiliency at an intake system 210, othermechanisms for ensuring data resiliency may additionally oralternatively be used.

As will be appreciated in view of the present disclosure, theconfiguration and operation of the intake system 210 can further providehigh amounts of security to the messages of that system. Illustratively,the intake ingestion buffer 306 or output ingestion buffer 310 maymaintain an authorization record indicating specific devices or systemswith authorization to publish or subscribe to a specific topic on theingestion buffer. As such, an ingestion buffer may ensure that onlyauthorized parties are able to access sensitive data. In some instances,this security may enable multiple entities to utilize the intake system210 to manage confidential information, with little or no risk of thatinformation being shared between the entities. The managing of data orprocessing for multiple entities is in some instances referred to as“multi-tenancy.”

Illustratively, a first entity may publish messages to a first topic onthe intake ingestion buffer 306, and the intake ingestion buffer 306 mayverify that any intake point or data source 202 publishing to that firsttopic be authorized by the first entity to do so. The streaming dataprocessors 308 may maintain rules specific to the first entity, whichthe first entity may illustrative provide through authenticated sessionon an interface (e.g., GUI, API, command line interface (CLI), etc.).The rules of the first entity may specify one or more entity-specifictopics on the output ingestion buffer 310 to which messages containingdata of the first entity should be published by the streaming dataprocessors 308. The output ingestion buffer 310 may maintainauthorization records for such entity-specific topics, thus restrictingmessages of those topics to parties authorized by the first entity. Inthis manner, data security for the first entity can be ensured acrossthe intake system 210. Similar operations may be performed for otherentities, thus allowing multiple entities to separately andconfidentially publish data to and retrieve data from the intake system.

4.2. Indexing

FIG. 8 is a data flow diagram illustrating an embodiment of the dataflow and communications between a variety of the components of the dataintake and query system 108 during indexing. Specifically, FIG. 8 is adata flow diagram illustrating an embodiment of the data flow andcommunications between an ingestion buffer 310, an ingest manager 406, apartition manager 408, a resource monitor 418, a resource catalog 420,an indexing node 404 or an indexer 410 or bucket manager 414, commonstorage 216, and/or a data store catalog 220. However, it will beunderstood, that in some of embodiments, one or more of the functionsdescribed herein with respect to FIG. 8 can be omitted, performed in adifferent order and/or performed by a different component of the dataintake and query system 108. Accordingly, the illustrated embodiment anddescription should not be construed as limiting.

At (1), the ingestion buffer 310 of the intake system 210 sends datarecords and buffer locations using one or more partitions to the ingestmanager 406. A buffer location can refer to the location in theingestion buffer 310 where a particular data record can be accessed. Insome embodiments, a data record can include data associated with aparticular tenant or a reference to a location (e.g. physical or logicaldirectory, file name, etc.) that stores the data associated with thetenant that is to be processed by the indexing system 212. In certainembodiments, the data record can also include a data identifier for thedata, such as a tenant identifier identifying the tenant to which thedata (either in the data record or at the location referenced by thedata record) is associated. The data in the data record or in thelocation referenced by the data record can include any one or anycombination of: raw machine data, structured data, unstructured data,performance metrics data, correlation data, data files, directories offiles, data sent over a network, event logs, registries, JSON blobs, XMLdata, data in a data model, report data, tabular data, messagespublished to streaming data sources, data exposed in an API, data in arelational database, sensor data, image data, or video data, etc.

In some embodiments, the ingestion buffer 310 can operate according to apub-sub messaging service. As such, the ingestion buffer 310 cancommunicate the data records of the one or more partitions to the ingestmanager 406, and also ensure that the data records of the partitions areavailable for additional reads until the ingestion buffer 310 receivesan acknowledgement from a partition manager 408 or an indexing node 404that the data can be removed. In some cases, the ingestion buffer 310can use one or more read pointers or location markers to track data thathas been communicated to the ingest manager 406 but that has not beenacknowledged for removal. Accordingly, based on the location markers,the ingestion buffer 310 can retain a portion of its data persistentlyuntil it receives confirmation that the data can be deleted or has beenstored in common storage 216. As the ingestion buffer 310 receivesacknowledgments, it can update the location markers. In some cases, theingestion buffer 310 can include at least one location marker for eachpartition. In this way, the ingestion buffer 310 can separately trackthe progress of the data reads in the different partitions.

In certain embodiments, the ingest manager 406 or partition managers 408can receive (and/or store) the location markers in addition to or aspart of the data records received from the ingestion buffer 310.Accordingly, the ingest manager 406 can track the location of the datain the ingestion buffer 310 that the ingest manager 406 has receivedfrom the ingestion buffer 310. In this way, if a partition manager 408becomes unavailable or fails, the ingest manager 406 can assign adifferent partition manager 408 to manage the data from the ingestionbuffer 310 and provide the partition manager 408 with a location fromwhich the partition manager 408 can obtain the data. Similarly, if anindexing node 404 becomes unavailable or fails, the partition manager408 or resource monitor 418 can assign a different indexing node 404 toprocess or manage data from the ingestion buffer 310 and provide theindexing node 404 with a location from which the indexing node 404 canobtain the data record from the ingestion buffer 310.

At (2), the ingest manager 406 activates a partition manager 408 for apartition. As described herein, the ingest manager 406 can receive datarecords from the ingestion buffer 310 across multiple partitions. Insome embodiments, the ingest manager 406 can activate (for example,generate or assign) a particular partition manager 408 for a particularpartition of the ingestion buffer 310. In this way, the particularpartition manager 408 receives the data records corresponding to theparticular partition of the ingestion buffer 310. In some cases, theingest manager 406 activates a different partition manager 408 for eachof the partitions of the ingestion buffer 310. In some cases, the ingestmanager 406 activates a partition manager 408 to manage data recordsfrom multiple partitions. In some embodiments, the ingest manager 406can activate a partition manager 408 based on the output of anadditional partition from the intake system 210, based on a partitionmanager 408 becoming unresponsive or unavailable, etc. In someembodiments, the partition manager 408 can be a copy of the ingestmanager 406 or a copy of a template process. In certain embodiments, thepartition manager 408 can be instantiated in a separate container fromthe ingest manager 406.

At (3), the resource monitor 418 monitors the indexing nodes 404 of theindexing system 212. As described herein, monitoring the indexing nodes404 can include requesting and/or receiving status information from theindexing nodes 404. In some embodiments, the resource monitor 418passively receives status information from the indexing nodes 404without explicitly requesting the information. For example, the indexingnodes 404 can be configured to periodically send status updates to theresource monitor. In certain embodiments, the resource monitor 418receives status information in response to requests made by the resourcemonitor 418. As described herein, the status information can include anyone or any combination of indexing node identifiers, metrics (e.g., CPUutilization, available memory), network architecture data, or indexingnode assignments, etc.

At (4), the resource monitor 418 can use the information received fromthe indexing nodes 404 to update the resource catalog 420. As the statusof indexing nodes 404 change over time, the resource monitor 418 canupdate the resource catalog 420. In this way, the resource monitor 418can maintain the resource catalog 420 with information about theindexing nodes 404 of the indexing system 212.

It will be understood that (3) and (4) may be repeated togetherperiodically, according to a schedule, policy, or algorithm, such thatthe current (or reasonably current) availability, responsiveness, and/orutilization rate of the indexing nodes 404 and/or indexers 410 is storedin resource catalog 420. For example, a time-based schedule may be usedso that (3) and (4) may be performed every X number of seconds, or everyX minute(s), and so forth. The performance of (3) on a periodic basismay be referred to as a “heartbeat.”

At (5), a partition manager 408 assigned to distribute one or more datarecords from a partition of the ingestion buffer 310 to one or moreindexers 410 requests an indexing node assignment from the resourcemonitor 418 and/or resource catalog 420. In some cases, the partitionmanager 408 requests an indexing node assignment based on an indexingnode mapping policy. The indexing node mapping policy can use any one orany combination of data identifiers, time period, etc. to indicate howindexing nodes 404 should be assigned to process data records. In somecases, based on the indexing node mapping policy, the partition manager408 requests an indexing node assignment for each data record or for agroup of data records. For example, the partition manager 408 canrequest an indexing node assignment for some or all data recordsassociated with the same tenant identifier or other data identifier. Insome such cases, the partition manager 408 can include the dataidentifier associated with the data record(s) in its request for anindexing node assignment.

In certain cases, based on the indexing node mapping policy, thepartition manager 408 requests an indexing node assignment for aparticular amount of time, such as one minute, five minutes, etc. Insome embodiments, based on the indexing node mapping policy, thepartition manager 408 can request an indexing node assignment for datarecords based on a combination of data identifiers and time. Forexample, the partition manager can request an indexing node assignmentfor data records associated with the same tenant identifier for oneminute, five minutes, etc.

In certain embodiments, based on the indexing node mapping policy, thepartition manager 408 requests an indexing node identifier for theindexing node 404 that is to process a data record or group of datarecords. As described herein, the indexing node identifier can includean IP address, location address, or other identifier that can be used toidentify a particular indexing node that is to process the data recordor group of data records.

At (6) the resource monitor 418 identifies the indexing node assignmentbased on the indexing node mapping policy. As described herein, theindexing node mapping policy can use a variety of techniques to make anindexing node assignment. In some cases, the indexing node mappingpolicy can indicate that indexing node assignments are to be made basedon any one or any combination of: a data identifier associated with thedata record(s), availability of indexing nodes or other information fromthe resource catalog 420 such as indexing node identifiers associatedwith the indexing nodes 404, a hashing or consistent hashing scheme, atime period, etc.

In some embodiments, based on the indexing node policy, the resourcemonitor assigns one or a group of indexing nodes 404 to process datarecords with the same data identifier (e.g., tenant identifier). Incertain embodiments, based on the indexing node mapping policy, theresource monitor 418 assigns data records with the same data identifierto the same indexing node 404 (or group of indexing nodes 404) for aparticular time interval.

In some embodiments, based on the indexing node mapping policy, theresource monitor 418 identifies available indexing nodes using theinformation from the resource catalog 420 and assigns one of theavailable indexing nodes 404 to process the data record. As describedherein, the resource monitor 418 can identify an available indexing nodeusing various techniques. For example, the resource monitor 418 canconsult the resource catalog 420 to identify an available indexing node.

In certain embodiments, based on the indexing node mapping policy, theresource monitor 418 maps the data identifier to one or more indexingnodes 404 and then makes the indexing node assignment based on theavailability of the one or more indexing nodes 404. In some cases, theresource monitor 418 identifies available indexing nodes 404 and thenmaps the data identifier to one or more of the available indexing nodes404. In some embodiments, based on the indexing node mapping policy, theresource monitor 418 maps the data identifier to one or more indexingnodes 404 using a hash or consistent hash scheme. In certainembodiments, based on the indexing node mapping policy and for aparticular time interval, the resource monitor 418 identifies theindexing node assignment for data records associated with the sametenant using a consistent hash that maps the tenant identifier toindexing node identifiers on a hash ring.

In some cases, based on the indexing node mapping policy, a new indexingnode can be generated and assigned to process the data record. Forexample, if the resource monitor 418 determines that there areinsufficient indexing nodes 404 or that the indexing nodes are too busy(e.g., satisfy a utilization threshold), the resource monitor 418 canrequest that a new indexing node 404 be instantiated and assign thenewly instantiated indexing node 404 to process the data record.

At (7), the resource monitor 418 communicates the indexing nodeassignment to the partition manager 408. In some cases, the indexingnode assignment can include an identifier of the indexing node 404 thatis to process the data record. In certain embodiments, the indexing nodeassignment can include other information, such as a time interval forwhich the assignment is to last, a backup indexing node 404 in the eventthe assigned indexing node 404 is not available or fails, etc. Thepartition manager 408 can use the information from the indexing nodeassignment to communicate the data records to a particular indexingnode.

In some embodiments, (5), (6), and (7) can be omitted. For example,instead of requesting and receiving an indexing node assignment from theresource monitor 418, the partition manager 408 can consult an indexingnode assignment listing that identifies recent indexing nodeassignments. The indexing node assignment listing can include a table orlist of data identifiers and indexing nodes 404 that have processed, orare assigned to process, data associated with the data identifiers. Thetable or list can be stored as a lookup table or in a database, etc. Insome embodiments, if the partition manager 408 determines that anindexing node 404 is already assigned to process data associated withthe data identifier, the partition manager 408 can omit (5), (6), and(7), and send the data to the assigned indexing node 404 for processing.In certain embodiments, if the partition manager 408 determines that anindexing node 404 is not assigned to process data associated the dataidentifier, the partition manager 408 can proceed with steps (5), (6),and (7), and store the results of the indexing node assignment in theindexing node assignment listing.

In certain embodiments, indexing node assignments can be temporary. Forexample, indexing nodes 404 can be dynamically added or removed from theindexing system 212. Accordingly, to accommodate the change in indexingnodes 404, the indexing node assignments can be periodically redone. Tofacilitate the reassignment, the indexing node assignment listing can becleared or deleted periodically. For example, each 15, 30, 60, or 90seconds, the indexing node assignment listing can be cleared or removed.In certain embodiments, the indexing node assignment listing can includea timestamp indicating when a particular assignment was made. After apredetermined time period, the particular indexing node assignment canbe deleted. Accordingly, different entries of the indexing nodeassignment listing can change at different times.

In some cases, a different indexing node assignment listing can bestored on or associated with each different partition manager 408. Forexample, a particular partition manager 408 can manage its own indexingnode assignment listing by cataloging the indexing node assignmentsreceived from the resource monitor 418. As another example, the ingestmanager 406 can manage some or all of the indexing node assignmentlistings of its partition managers 408. In some cases, an indexing nodeassignment listing can be associated with some or all of the partitionmanagers 408. For example, the ingest manager 406 or the partitionmanagers 408 can manage the indexing node assignment listing bycataloging the indexing node assignments received from the resourcemonitor 418.

At (8), the ingest manager 406 tracks the buffer location and thepartition manager(s) 408 communicate the data to the indexer(s) 410. Asdescribed herein, the ingest manager 406 can track (and/or store) thebuffer location for the various partitions received from the ingestionbuffer 310. In addition, as described herein, the partition manager 408can forward the data received from the ingestion buffer 310 to theindexer(s) 410 for processing. In various implementations, as previouslydescribed, the data from ingestion buffer 310 that is sent to theindexer(s) 410 may include a path to stored data, e.g., data stored incommon storage 216 or another common storage, which is then retrieved bythe indexer 410 or another component of the indexing node 404.

As described herein, in some embodiments, the partition manager 408 cancommunicate different records to different indexing nodes 404. Forexample, the partition manager 408 can communicate records associatedwith one tenant (or one data identifier) to one indexing node 404 andrecords associated with another tenant (or another data identifier) toanother indexing node 404. Accordingly, the partition manager 408 canconcurrently distribute data associated with different tenants todifferent indexing nodes 404 for processing. In some cases, data recordsassociated with different tenants can be communicated to the sameindexing node 404 for processing. For example, based on the indexingnode mapping policy, the same indexing node 404 may be mapped to datafrom different tenants. As such, the partition manager 406 cancommunicate data from different tenants to the same indexing node 404.As a corollary, an indexing node 404 can receive and concurrentlyprocess data from different tenants.

At (9), the indexer 410 processes the data records. As described herein,in some cases, the data records include the data that is to be furtherprocessed by the indexing node 404. In some such embodiments, theindexing node 404 can process the data in the data records. In certainembodiments, the data records include a reference to the data that is tobe further processed by the indexing node 404. In some such embodiments,the indexing node 404 can access and process the data using thereference in the data record. As described herein, the indexer 410 canperform a variety of functions, enrichments, or transformations on thedata as it is indexed. For example, the indexer 410 can parse the data,identify events from the data, identify and associate timestamps withthe events, associate metadata or one or more field values with theevents, group events (e.g., based on time, partition, and/or tenant ID,etc.), etc. Furthermore, the indexer 410 can generate buckets based on abucket creation policy and store the events in the hot buckets, whichmay be stored in a data store 412 of the indexing node 404 associatedwith that indexer 410 (see FIGS. 4A and/or 4B). As described herein,when generating buckets, the indexer 410 can generate separate bucketsfor data associated with different tenants and/or indexes.

With reference to (1), (8), and (9), it will be understood that dataassociated with different data identifiers can be concurrently received,distributed, and/or processed by the same partition of the ingestionbuffer 310, the same partition manager 408 and/or the same indexer 410.Similarly, data associated with the same data identifier can beconcurrently received, distributed, and/or processed by differentpartitions of the ingestion buffer 310, different partition managers 408and/or different indexers 410.

With reference to (1), it will be understood that data recordsassociated with different identifiers can be found in the same partitionof the ingestion buffer 310 and that data records associated with thesame data identifier can be found across different partitions of theingestion buffer 310. For example, Partition 1 of ingestion buffer 310can include data from Tenant A and Tenant B, and Partition 2 can includedata from Tenant A and Tenant C.

With reference to (1) and (8), one partition manager 408 can receive anddistribute data associated with different data identifiers, anddifferent partition managers 408 can receive and distribute dataassociated with the same data identifier. With continued reference tothe example, Partition Manager 1 associated with Partition 1 can processand distribute data from Tenant A and Tenant B (the data fromPartition 1) and Partition Manager 2 association with Partition 2 canprocess and distribute data from Tenant A and Tenant C (the data fromPartition 2).

With reference to (9), indexing nodes 404 can receive and concurrentlyprocess data associated with the same data identifier from differentpartition managers 408 (or from the same partition manager 408) and dataassociated with different data identifiers from the same partitionmanager 408 (or from different partition managers 408). With continuedreference to the example above, based on an indexing node mappingpolicy, Indexer 1 can be assigned to receive and process Tenant A datafrom Partition Managers 1 and 2, and to receive and process Tenant Cdata from Partition Manager 2.

At (10), the indexer 410 copies and/or stores the data to common storage216. For example, the indexer 410 can determine (and/or the partitionmanager 408 can instruct the indexer 410) to copy the data to commonstorage 216 based on a bucket roll-over policy. The bucket roll-overpolicy can use any one or any combination of bucket size, data size,time period, etc. to determine that the data is to be copied to commonstorage 216.

In some cases, based on the bucket roll-over policy, the indexer 410periodically determines that the data is to be copied to common storage216. For example, the bucket roll-over policy may indicate a time-basedschedule so that the indexer 410 determines to copy and/or store thedata every X number of seconds, or every X minute(s), and so forth. Asanother example, the bucket roll-over policy may indicate that one ormore buckets are to be rolled over based on size. Accordingly, in someembodiments, the indexer 410 can determine to copy the data to commonstorage 216 based on a determination that the amount of data stored onthe indexer 410 satisfies a threshold amount. The threshold amount cancorrespond to the amount of data being processed by the indexer 410 forany partition or any tenant identifier. In some cases, the bucketroll-over policy may indicate that one or more buckets are to be rolledover based on a combination of a time-based schedule and size. Forexample, the bucket roll-over policy may indicate a time-based schedulein combination with a data threshold. For example, the indexer 410 candetermine to copy the data to common storage 216 based on adetermination that the amount of data stored on the indexer 410satisfies a threshold amount or a determination that the data has notbeen copied in X number of seconds, X number of minutes, etc.Accordingly, in some embodiments, the indexer 410 can determine that thedata is to be copied to common storage 216 without communication withthe partition manager 408 or the ingest manager 416.

In some cases, based on the bucket roll-over policy, the partitionmanager 408 can instruct the indexer 410 to copy the data to commonstorage 216. For example, the bucket roll-over policy may indicate thatone or more buckets are to be rolled over based on time and/or size. Insome such cases, the partition manager 408 can determine to instruct theindexer 410 to copy the data to common storage 216 based on adetermination that the amount of data stored on the indexer 410satisfies a threshold amount. The threshold amount can correspond to theamount of data associated with the partition that is managed by thepartition manager 408 or the amount of data being processed by theindexer 410 for any partition. For example, the indexer 410 can reportand/or the partition manager 408 can monitor the size of the data beingindexed to the partition manager 408 and/or the size of data beingprocessed by the indexer 410 for any partition or any tenant identifier.

In some such cases, the indexer 410 can report the size of the data inthe aggregate and/or the size of the data for each data identifier. Forexample, the indexer 410 can include the size of the data beingprocessed for one tenant and the size of the data being processed for adifferent tenant.

In some cases, the indexer 410 can routinely provide a status update tothe partition manager 408 regarding the data. The status update caninclude, but is not limited to the size of the data, the number ofbuckets being created, the amount of time since the buckets have beencreated, etc. In some embodiments, the indexer 410 can provide thestatus update based on one or more thresholds being satisfied (e.g., oneor more threshold sizes being satisfied by the amount of data beingprocessed, one or more timing thresholds being satisfied based on theamount of time the buckets have been created, one or more bucket numberthresholds based on the number of buckets created, the number of hot orwarm buckets, number of buckets that have not been stored in commonstorage 216, etc.).

In certain cases, the indexer 410 can provide an update to the partitionmanager 408 regarding the size of the data that is being processed bythe indexer 410 in response to one or more threshold sizes beingsatisfied. For example, each time a certain amount of data is added tothe indexer 410 (e.g., 5 MB, 10 MB, etc.), the indexer 410 can reportthe updated size to the partition manager 408. In some cases, theindexer 410 can report the size of the data stored thereon to thepartition manager 408 once a threshold size is satisfied.

In certain embodiments, the indexer 410 reports the size of the databeing indexed to the partition manager 408 based on a query by thepartition manager 408. In certain embodiments, the indexer 410 andpartition manager 408 maintain an open communication link such that thepartition manager 408 is persistently aware of the amount of data on theindexer 410.

In some cases, a partition manager 408 monitors the data processed bythe indexer 410. For example, the partition manager 408 can track thesize of the data on the indexer 410 that is associated with thepartition being managed by the partition manager 408. In certain cases,one or more partition managers 408 can track the amount or size of thedata on the indexer 410 that is associated with any partition beingmanaged by the ingest manager 406 or that is associated with theindexing node 404.

Any one or any combination of the aforementioned reporting or monitoringcan be done for different data or data associated with different dataidentifiers. For example, the indexers 410 can use one reporting schemefor data associated with one tenant and another reporting scheme fordata associated with a different tenant. Similarly, the indexers 410 canseparately report information for different data. Furthermore, thepartition manager 408 can monitor/track the data processed by theindexer 410 for different data identifiers.

In some cases, the partition manager 408 can instruct the indexer 410 tocopy the data that corresponds to the partition being managed by thepartition manager 408 to common storage 216 based on the size of thedata that corresponds to the partition satisfying the threshold amount.In certain embodiments, the partition manager 408 can instruct theindexer 410 to copy the data associated with any partition beingprocessed by the indexer 410 to common storage 216 based on the amountof the data from the partitions that are being processed by the indexer410 satisfying the threshold amount and/or an amount of time that haspassed since a bucket was stored to common storage 216, etc.

As described herein, the partition manager and/or indexer 410 can usedifferent bucket roll-over policies for buckets associated withdifferent data identifiers. For example, the indexer 410 can use onebucket roll-over policy (or thresholds) for buckets associated with onetenant and a bucket roll-over policy (or thresholds) for bucketsassociated with a different tenant. As such, an indexer 410 may copydata associated with one data identifier more or less frequently thandata associated with another identifier, or use different criteria todetermine when to copy data associated with the different dataidentifiers.

As part of storing the data to common storage 216, the indexer 410 canverify or obtain acknowledgements that the data is stored successfully.In some embodiments, the indexer 410 can determine information regardingthe data stored in the common storage 216. For example, the informationcan include location information regarding the data that was stored tothe common storage 216, bucket identifiers of the buckets that werecopied to common storage 216, as well as additional information, e.g.,in implementations in which the ingestion buffer 310 uses sequences ofrecords as the form for data storage, the list of record sequencenumbers that were used as part of those buckets that were copied tocommon storage 216.

When storing the data to common storage 216, the indexer 410 canphysically and/or logically separate data or buckets associated withdifferent data identifiers. For example, the indexer 410 can storebuckets associated with Tenant A in a separate directory, filestructure, or data store from buckets associated with Tenant B. In thisway, the indexer 410 can maintain the mutual exclusivity and/orindependence between data from different tenants. Similarly, the indexer410 can physically and/or logically separate data or buckets associatedwith different indexes of a tenant.

At (11), the indexer 410 reports or acknowledges to the partitionmanager 408 that the data is stored in the common storage 216. Invarious implementations, this can be in response to periodic requestsfrom the partition manager 408 to the indexer 410 regarding whichbuckets and/or data have been stored to common storage 216. The indexer410 can provide the partition manager 408 with information regarding thedata stored in common storage 216 similar to the data that is providedto the indexer 410 by the common storage 216. In some cases, (11) can bereplaced with the common storage 216 acknowledging or reporting thestorage of the data to the partition manager 408 and/or the indexer 410.

At (12), the indexer 410 updates the data store catalog 220. Asdescribed herein, the indexer 410 can update the data store catalog 220with information regarding the data or buckets stored in common storage216. For example, the indexer 410 can update the data store catalog 220to include location information, a bucket identifier, a time range, andtenant and partition information regarding the buckets copied to commonstorage 216, etc. In this way, the data store catalog 220 can includeup-to-date information regarding the buckets stored in common storage216.

At (13), the partition manager 408 reports the completion of the storageto the ingestion buffer 310 and/or another data store (for example,DynamoDB) that stores that stores the location marker information, andat (14), the ingestion buffer 310 updates the buffer location or markerand/or the another store updates it marker. Accordingly, in someembodiments, the ingestion buffer 310 and/or the another database systemcan maintain the location marker for a particular data record until theingestion buffer 310 (or other data store) receives an acknowledgementthat the data that the ingestion buffer 310 sent to the indexing node404 has been indexed by the indexing node 404 and stored to commonstorage 216. In addition, the updated buffer location or marker can becommunicated to and stored by the ingest manager 406. In this way, adata intake and query system 108 can use the ingestion buffer 310 toprovide a stateless environment for the indexing system 212. Forexample, as described herein, if an ingest manager 406, partitionmanager 408, indexing node 404 or one of its components (e.g., indexer410, data store 412, etc.) becomes unavailable or unresponsive beforedata from the ingestion buffer 310 is copied to common storage 216, theindexing system 212 can generate or assign a new component, to processthe data that was assigned to the now unavailable component whilereducing, minimizing, or eliminating data loss.

At (15), a bucket manager 414, which may form part of the indexer 410,the indexing node 404, or indexing system 212, merges multiple bucketsinto one or more merged buckets. As described herein, to reduce delaybetween processing data and making that data available for searching,the indexer 410 can convert smaller hot buckets to warm buckets and copythe warm buckets to common storage 216. However, as smaller buckets incommon storage 216 can result in increased overhead and storage costs,the bucket manager 414 can monitor warm buckets in the indexer 410 andmerge the warm buckets into one or more merged buckets.

In some cases, the bucket manager 414 can merge the buckets according toa bucket merge policy. As described herein, the bucket merge policy canindicate which buckets are candidates for a merge (e.g., based on timeranges, size, tenant, index, or other identifiers, etc.), the number ofbuckets to merge, size or time range parameters for the merged buckets,a frequency for creating the merged buckets, etc. It will be understoodthat the bucket manager 414 can use different bucket merge policies fordata associated with different data identifiers. For example, the bucketmanager 414 can merge buckets associated with one tenant using a firstbucket merge policy and buckets associated with a second tenant using asecond bucket merge policy.

At (16), the bucket manager 414 stores and/or copies the merged data orbuckets to common storage 216, and obtains information about the mergedbuckets stored in common storage 216. Similar to (7), the obtainedinformation can include information regarding the storage of the mergedbuckets, such as, but not limited to, the location of the buckets, oneor more bucket identifiers, tenant or partition identifiers, etc. At(17), the bucket manager 414 reports the storage of the merged data tothe partition manager 408, similar to the reporting of the data storageat (11).

At (18), the indexer 410 deletes data from the data store (e.g., datastore 412). As described herein, once the merged buckets have beenstored in common storage 216, the indexer 410 can delete correspondingbuckets that it has stored locally according to a bucket managementpolicy. For example, the indexer 410 can delete the merged buckets fromthe data store 412, as well as the pre-merged buckets (buckets used togenerate the merged buckets). By removing the data from the data store412, the indexer 410 can free up additional space for additional hotbuckets, warm buckets, and/or merged buckets.

At (19), the common storage 216 deletes data according to a bucketmanagement policy. As described herein, once the merged buckets havebeen stored in common storage 216, the common storage 216 can delete thepre-merged buckets stored therein. In some cases, as described herein,the common storage 216 can delete the pre-merged buckets immediately,after a predetermined amount of time, after one or more queries relyingon the pre-merged buckets have completed, or based on other criteria inthe bucket management policy, etc. In certain embodiments, a controllerat the common storage 216 handles the deletion of the data in commonstorage 216 according to the bucket management policy. In certainembodiments, one or more components of the indexing node 404 delete thedata from common storage 216 according to the bucket management policy.However, for simplicity, reference is made to common storage 216performing the deletion. As described herein, it will be understood thatdifferent bucket management policies can be used for data associatedwith different data identifiers. For example, the indexer 410 or commonstorage 216 can use one bucket management policy for buckets associatedwith one tenant and another bucket management policy for bucketsassociated with a different tenant.

At (20), the indexer 410 updates the data store catalog 220 with theinformation about the merged buckets Similar to (12), the indexer 410can update the data store catalog 220 with the merged bucketinformation. The information can include, but is not limited to, thetime range of the merged buckets, location of the merged buckets incommon storage 216, a bucket identifier for the merged buckets, tenantand partition information of the merged buckets, etc. In addition, aspart of updating the data store catalog 220, the indexer 410 can removereference to the pre-merged buckets. Accordingly, the data store catalog220 can be revised to include information about the merged buckets andomit information about the pre-merged buckets. In this way, as thesearch managers 514 request information about buckets in common storage216 from the data store catalog 220, the data store catalog 220 canprovide the search managers 514 with the merged bucket information.

As mentioned previously, in some of embodiments, one or more of thefunctions described herein with respect to FIG. 8 can be omitted,performed in a variety of orders and/or performed by a differentcomponent of the data intake and query system 108. For example, theindexer 410 can (12) update the data store catalog 220 before, after, orconcurrently with the deletion of the data in the (18) indexer 410 or(19) common storage 216. Similarly, in certain embodiments, the indexer410 can (15) merge buckets before, after, or concurrently with(10)-(14), etc. As another example, the partition manager 408 canperform (12) and/or (14). In some cases, the indexer 410 can update thedata store catalog 220 before, after, or concurrently with (17)-(19),etc.

In some cases, (1)-(4) can be performed in any order, or concurrentlywith each other. For example, the ingest manager 416 can generate thepartition managers 408 before or after receiving data from the ingestionbuffer 310, while the resource monitor 418 concurrently monitors theindexers 410 and updates the resource catalog 420.

In certain embodiments, such as when an indexing system 212 isinstantiated for a single tenant, (3)-(7) may be omitted. For example,in some such embodiments, the indexing system 212 may not include aresource monitor 418 and/or resource catalog 420 and/or the indexingsystem 212 may have dedicated indexing nodes 404 for the tenant. In somesuch cases, the partition manager 408 can be configured to send the datato a particular indexer 410.

As another example, in some cases, the partition manager 408 may notrequest an indexer assignment from the resource monitor 418. In somesuch cases, the ingest manager 406 or partition manager 408 candetermine the indexer assignment. For example, the ingest manager 406 orpartition manager 408 can use an indexing node mapping policy toidentify an indexer 410 to process a particular data record. As anotherexample, the partition manager 408 may use an indexing node assignmentlisting to determine that a data record associated with a dataidentifier has already been assigned to a particular indexer 410. Insome such cases, the partition manager 408 can communicate the datarecord to the particular indexer 410 without requesting an indexerassignment from the resource monitor 418.

In some embodiments, the one or more components of the indexing system212 and/or the ingestion buffer 310 can concurrently process data frommultiple tenants. For example, each partition of the ingestion buffer310 can include data records associated with different tenants. In somecases, a data record can include data associated with one tenant anddifferent data records can include data from different tenants. Incertain cases, a data record can include location and/or identificationinformation of data or a file with data from a particular tenant and/ora tenant identifier corresponding to the particular tenant. For eachdata record, the partition manager 408 can request an indexing nodeassignment to process the data record, the resource monitor 418 canprovide an indexing node assignment for the data record, and theassigned indexing node 404 can process the data record (including anydata referenced by the data record). The ingest manager 406/partitionmanager 408, the resource monitor 418, and/or the indexer 410 canconcurrently process multiple data records in this manner. As differentdata records can be associated with different tenants, the ingestmanager 406 ingest manager 406/partition manager 408, the resourcemonitor 418, and/or the indexer 410 can concurrently process dataassociated with different tenants.

In certain embodiments, the components of the indexing system 212 mayonly process data from one tenant. For example, the ingestion buffer 310can be configured to only process data from one tenant. Correspondingly,the data records received and processed by the ingest manager406/partition manager 408 and/or indexer 410 can correspond to the sametenant. In some embodiments in which the components of the indexingsystem 212 only process data from one tenant, the resource monitor 418and/or resource catalog 420 (and corresponding (3), (4), (5), (6)) canbe omitted. In some such embodiments, the ingest manager 406/partitionmanager 408 may form part of an indexing node 404 as illustrated at FIG.4A and/or the data records from the partition manager 408 can be sent toone of a group of indexers 410 designated for the particular tenantusing a load balancing scheme. Further, in some embodiments in which thecomponents of the indexing system 212 only process data from one tenant,separate ingestion buffer(s) 310, ingest manager(s) 406/partitionmanager(s) 408, resource monitor(s) 418, resource catalog(s) 420,indexer(s) 410, and bucket manager(s) 414 can be instantiated for eachtenant.

4.3. Querying

FIG. 9 is a data flow diagram illustrating an embodiment of the dataflow and communications between a variety of the components of the dataintake and query system 108 in relation to a query. Specifically, FIG. 9is a data flow diagram illustrating an embodiment of the data flow andcommunications between the indexing system 212, data store catalog 220,metadata catalog 221, query system manager 502, search head(s) 504,resource monitor 508, resource catalog 510, search nodes 506, commonstorage 216, and the query acceleration data store 222. However, it willbe understood, that in some of embodiments, one or more of the functionsdescribed herein with respect to FIG. 9 can be omitted, performed in adifferent order and/or performed by a different component of the dataintake and query system 108. For example, in some embodiments, the stepsidentified as being performed by the query system manager 502 and searchhead 504 can be performed by the same component (e.g., the query systemmanager 502, the search head 504, or another component of the dataintake and query system 108). In some such embodiments, (6) can beomitted. Accordingly, the illustrated embodiment and description shouldnot be construed as limiting.

Further, it will be understood that the various functions describedherein with respect to FIG. 9 can be performed by one or more distinctcomponents of the data intake and query system 108. For example, forsimplicity, reference is made to a search head 504 performing one ormore functions. However, it will be understood that these functions canbe performed by one or more components of the search head 504, such as,but not limited to, the search master 512 and/or the search manager 514.Similarly, reference is made to the indexing system 212 performing oneor more functions. However, it will be understood that the functionsidentified as being performed by the indexing system 212 can beperformed by one or more components of the indexing system 212.

At (1) and (2), the indexing system 212 monitors the storage ofprocessed data and updates the data store catalog 220 based on themonitoring. As described herein, one or more components of the indexingsystem 212, such as the partition manager 408 and/or the indexer 410 canmonitor the storage of data or buckets to common storage 216. As thedata is stored in common storage 216, the indexing system 212 can obtaininformation about the data stored in the common storage 216, such as,but not limited to, location information, bucket identifiers, tenantidentifier (e.g., for buckets that are single tenant) etc. The indexingsystem 212 can use the received information about the data stored incommon storage 216 to update the data store catalog 220.

Furthermore, as described herein, in some embodiments, the indexingsystem 212 can merge buckets into one or more merged buckets, store themerged buckets in common storage 216, and update the data store catalogto 220 with the information about the merged buckets stored in commonstorage 216.

At (3A) the resource monitor 508 monitors some or all of the searchheads 504 and (3B) search nodes 506 (in the query system 214), includingthe specific search head 504 and search nodes 506 used to execute thequery, and (4) updates the resource catalog 510. As described herein,the resource monitor 508 can monitor the availability, responsiveness,and/or utilization rate of the search heads 504 and search nodes 506.Based on the status of the search heads 504 and the search nodes 506,the resource monitor 508 can update the resource catalog 510. In thisway, the resource catalog 510 can retain information regarding a currentstatus of each of the search heads 504 and the search nodes 506 in thequery system 214. It will be understood that (3A), (3B), and (4) may berepeated together periodically, according to a schedule, policy, oralgorithm, such that the current (or reasonably current) availability,responsiveness, and/or utilization rate of the search heads 504 and thesearch nodes 506 is stored in resource catalog 510. For example, atime-based schedule may be used so that (3A), (3B), and (4) may beperformed every X number of seconds, or every X minute(s), and so forth.The performance of (3A), (3B), and (4) on a periodic basis may bereferred to as a “heartbeat.”

The monitoring of the search heads 504 and search nodes 506 may allowfor improved resource utilization through the implementation of dynamicresource scaling. Resource scaling can be performed by provisioningadditional search heads 504 and/or search nodes 506 (“spinning up”) ordecommissioning idle search heads 504 and/or search nodes 506 (“spinningdown”) based on various individual or aggregate capacity utilizationmetrics, such as CPU/memory utilization, the number of concurrentrunning searches, and so forth. For example, each search head 504 andeach search node 506 may periodically report (e.g., for a “heartbeat”)its status to the resource monitor 508, including information such asCPU/memory utilization and capacity, an indication of whether the searchhead is processing a search request (or if the search node is processingthe execution of a query), and so forth. Provisioning anddecommissioning resources can be performed based on applying analgorithm or a policy to the capacity utilization metrics. For instance,there may be different thresholds used for provisioning anddecommissioning resources. Thus, if many resources are being utilizedand a particular tenant requires more capacity than is available,additional resources can be spun up to meet that demand, or if not manyresources are being utilized, resources can be spun down to a minimumthreshold of idle computing.

In some embodiments one or more search heads 504, can be spun up orbased on search utilization. For instance, the current number ofconcurrently running searches may be known (e.g., from “heartbeats”received from the search heads). For instance, if based on the number ofsearch heads allocated 32 searches can be executed concurrently and only20 searches are being concurrently executed the query system 214 thatabout 60% of the search head capacity is being utilized. An upperthreshold can be set (e.g., above 80% capacity) and once that thresholdis satisfied, the number of search heads can be increased (e.g., by 5additional search heads). Once those new search heads are provisioned,they can start reporting (e.g., via “heartbeat”) to the resource monitor508 and the status of those search heads 504 can be tracked. Inembodiments in which information associated with a search request (e.g.,extraction rules, and so forth) are independently stored in a catalog(e.g., a metadata catalog 221) rather than passed as metadata associatedwith the search request to be locally stored on a search head, spinningup additional search heads 504, the query system 214 may be able to spinup a search head 504 relatively quickly given that configurationmanagement and synchronization between search heads 504 may not berequired and available search heads can be freely assigned to handle anysearch request associated with any tenant.

A lower threshold can also be set (e.g., below 20% capacity) and oncecapacity utilization decreases below the lower threshold, idle searchheads 504 or search nodes 506 can be decommissioned. In some cases,there may be a floor or minimum number of search heads that must beavailable at all times (e.g., 32 total search heads). For spinning downsearch heads 504, in some embodiments, the only requirement may be thata search head 504 must stop processing a search request before it can beremoved. In some embodiments, spinning up or down the number of searchheads 504 can be performed by the query system manager 502.

In the case of the search nodes 506, additional search nodes 506 may bespun up or spun down based on capacity utilization and/or based on thenumber of queries being executed. In some embodiments, a search node 506may be allocated to one query at a time. In some such embodiments, ifmore queries are requested than there are available search nodes or ifthe a threshold number of the total instantiated search nodes 506 are inuse, the query system 214 can instantiate an additional number of searchnodes 506.

In certain embodiments, such as where a search node 506 is concurrentlyassigned to multiple queries, spinning search nodes 506 up or down canbe based on capacity or resource utilization. For instance, the totalCPU/memory utilization and capacity across the search nodes 506 can bedetermined (e.g., by aggregating the individual CPU/memory utilizationand capacity for each search node). An upper threshold can be set (e.g.,above 80% utilization of total CPU/memory capacity) and once thatthreshold is exceeded, the number of search nodes can be increased(e.g., by 20 additional search nodes 506). Once the new search nodes 506are provisioned, they can start reporting (e.g., via “heartbeat”) to theresource monitor 508 and the status of those search nodes 506 can betracked. The new search nodes 506 can then available to be assigned to asearch head 504 (or search manager 514) to execute a query. As describedin greater detail herein, a variety of factors can be considered whenassigning search nodes 506.

A lower threshold can also be set (e.g., below 20% utilization of totalCPU/memory capacity) and once utilization drops below that lowerthreshold, certain search nodes may be decommissioned (e.g., searchnodes that were recently spun up). In some cases, there may be a set ofsearch nodes 506 that cannot be spun down first (e.g., the search nodeswith high cache hit ratio). In some embodiments, spinning up or down thenumber of search heads 504 can be performed by the query system manager502.

At (5), a search service or query system manager 502 receives andprocesses a user query. The user query can correspond to a queryreceived from a client device 204 and can include one or more queryparameters. In some cases, the user query can be received via thegateway 215 and/or via the network 208. The query can identify (and thequery parameters can include) a set of data and manner processing theset of data. In certain embodiments the set of data of a query caninclude multiple datasets. For example, the set of data of the query caninclude one or more source datasets, source reference datasets and/orquery datasets. In turn a dataset can include one or more queries (orsubqueries). For example, a query dataset can be identified as at leasta portion of the set of data of a received query, and can include aquery (or subquery) that identifies a set of data and a manner ofprocessing the set of data. As another example, the query dataset couldreference one or more additional query datasets that in turn include oneor more subqueries.

Furthermore, the query can include at least one dataset identifierand/or dataset association record identifier. In some embodiments, thedataset identifier can be a logical identifier of a dataset. In certainembodiments, the dataset identifier and/or dataset association recordidentifier can follow a particular query parameter, such as “from”“datasetID,” “moduleID,” etc. In some embodiments, the datasetidentifier and/or dataset association record identifier can be includedas a parameter of a command received by the query system manager 502.For example, in some embodiments, the data intake and query system 108can receive the query as one parameter and the dataset identifier and/orthe dataset association record as another parameter.

As part of processing the user query, the query system manager 502 canidentify the dataset identifier(s) and/or the dataset association recordidentifier. In some embodiments, the query system manager 502 can parsethe query to identify the dataset identifier and/or dataset associationrecord identifier. For example, the query system manager 502 canidentify “from” (or some other query parameter) in the query anddetermine that the subsequent string is the dataset identifier.Furthermore, it will be understood that the query system manager 502 canidentify multiple dataset identifier(s) and/or dataset associationrecord identifier(s) as part of processing the user query.

At (6), the query system manager 502 communicates with the metadatacatalog 221 to authenticate the datasets identified in the query (andother datasets parsed during the query processing), identify primarydatasets (e.g. datasets with configurations used to execute the query),secondary datasets (datasets referenced directly or indirectly by thequery but that do not include configurations used to execute the query)and/or identify query configuration parameters.

In some embodiments, upon identifying a dataset association record 602associated with the query, the query system manager 502 uses the datasetassociation record 602 to identify additional information associatedwith the user query, such as one or more datasets and/or rules. In someembodiments, using the dataset association record, the query systemmanager 502 can determine whether a user associated with the query hasthe authorizations and/or permissions to access the datasets identifiedin the query.

Once the query system manager 502 identifies the dataset of the datasetassociation record 602 referenced in the query, the query system manager502 can determine whether the identified dataset identifies one or moreadditional datasets (e.g., is a single or multi-reference dataset),includes additional query parameters, is a source dataset, a secondarydataset, and/or a primary dataset that will be used by the data intakeand query system to execute the query.

In the event, the dataset is a single or multi-reference dataset, witheach additional dataset identified, the query system manager 502 canrecursively review information about the dataset to determine whether itis a non-referential, single, or multi-reference dataset, a secondarydataset, and/or a primary dataset until it has identified any datasetreferenced directly or indirectly by the query (e.g., all primary andsecondary datasets). For example, as described in herein, the datasetidentifier used in the user query may refer to a dataset that is fromanother dataset association record. Based on the determination that thedataset is imported, the query system manager 502 can review the otherdataset association record to identify any additional datasets, identifyconfiguration parameter (e.g., access information, dataset type, etc.)of the imported dataset, and/or determine whether the referenced datasetwas imported from a third dataset. The query system manager 502 cancontinue to review the dataset association records 602 until it hasidentified the dataset association record where the dataset is native.

As another example, the dataset identifier in the user query may referto a multi-reference dataset, such as a query dataset that refers to oneor more source datasets, source reference datasets, and/or other querydatasets. Accordingly, the query system manager 502 can recursivelyreview the datasets referred to in the multi-reference dataset until itidentifies datasets that do not rely on any other datasets (e.g.,non-referential datasets) and/or identifies the source datasets thatinclude the data that forms at least a portion of the set of data orother primary datasets.

With each new dataset identified from the dataset association records,the query system manager 502 can authenticate the dataset. As part ofauthenticating the datasets, the query system manager 502 can determinewhether the dataset referred to is imported by the dataset associationrecord and/or whether the user has the proper credentials,authorizations, and/or permissions to access the dataset.

In addition to identifying additional datasets, the query system manager502 can identify additional query parameters. For example, one or moredatasets, such as a query dataset, may include additional queryparameters. Accordingly, as the query system manager 502 parses thevarious datasets, it can identify additional query parameters that areto be processed and/or executed.

Furthermore, as the query system manager 502 parses the datasetassociation records 602, it can identify one or more rules that are tobe used to process data from one or more datasets. As described herein,the rules can be imported by different dataset association records 602.Accordingly, the query system manager 502 can recursively parse therules to identify the dataset association record 602 from which the ruleoriginated. Furthermore, as the query system manager 502 parses thedataset association records 602 and identifies additional rules, it candetermine whether the user has the proper credentials permissions etc.to access the identified rules. In addition, the query system manager502 can identify one or more datasets associated with the rules (e.g.,that reference, use, are referenced by, or used by, the additionalrules). As described herein, in some embodiments these datasets may notbe explicitly imported in a dataset association record, but may beautomatically included as part of the query processing process.

In addition to identifying the various datasets and/or rules associatedwith the query, the query system manager 502 can identify theconfigurations associated with the datasets and rules associated withthe query. In some embodiments, the query system manager 502 can use thedataset configuration records 604 and/or rule configuration records 606to identify the relevant configurations for the datasets and/or rulesassociated with the query. For example, the query system manager 502 canrefer to the dataset configuration records 604 to identify the datasettypes of the various datasets associated with the query. In someembodiments, based on the dataset type, the query system manager 502 candetermine how to interact with or generate commands for the dataset. Forexample, for a lookup dataset, the query system manager may generate a“lookup” command, for an “index” dataset, the query system manager maygenerate a “search” command, and for a metrics interaction dataset, thequery system manager may generate an “mstats” command.

As described herein, in some embodiments, the dataset configurationrecords 604 and rule configuration records 606 can include a physicalidentifier for the datasets and/or rules. Accordingly, in someembodiments, the query system manager 502 can obtain the physicalidentifiers for each of the datasets and/or rules associated with thequery. In certain embodiments, the query system manager 502 candetermine the physical identifiers for each of the datasets and/or rulesassociated with the query based on the logical name and datasetassociation record 602 associated with the dataset or rule. For example,in certain embodiments, the physical identifier can correspond to acombination of the logical identifier of the dataset and the logicalidentifier of the associated dataset association record.

In some embodiments, when identifying the rule configuration records 606and/or dataset configuration records 604, the query system manager 502can obtain a subset of the dataset configuration records 604 and/or ruleconfiguration records 606 in the metadata catalog 221 and/or a subset ofthe dataset configuration records 604 and/or rule configuration records606 associated with the dataset association records 602 identified bythe query or referenced while processing the query. In certainembodiments, the query system manager 502 obtains only the datasetconfiguration records 604 and/or rule configuration records 606 that areneeded to process the query or only the primary dataset configurationrecords 604 and primary rule configuration records 606. For example, ifthe dataset association record 602 reference three datasets and tworules, but the query only uses one of the datasets and one of the rules,the query system manager 502 can obtain the dataset configuration record604 of the dataset referenced and the rule configuration record 606 inthe query but not the dataset configuration records 604 and ruleconfiguration records 606 of the datasets and rule not referenced in orused by the query.

At (7), the query system manager 502 requests a search head. Asdescribed herein the search heads 504 can be dynamically assigned toprocess queries associated with different tenants. Accordingly, prior toa search head 504 processing a query, the query system manager 502 orsearch service can request an identification of a search head for the(system) query from the resource monitor 508. In some cases, (7) can bedone before, after, or concurrently with (6). For example, the querysystem manager 502 can request the search head 504 before, after, orconcurrently with authenticating the datasets and/or identifying datasetsources.

At (8), the metadata catalog 221 generates annotations. As describedherein, the metadata catalog 221 can generate annotations based oninteractions with or changes to the metadata catalog 221. For example,based on the authentication of the datasets and identify the datasetsources, the metadata catalog 221 can generate one or more annotations.The annotations can include, but are not limited to, updating the numberof times a dataset is used, updating a dataset configuration recordbased on the search, generating a dataset configuration record based onthe query, identifying the user associated with the query, storing a jobID associated with the query in a dataset configuration record, etc. Asdescribed herein, in some cases, the metadata catalog 221 can generateannotations based on the content of a query. For example, if the queryindicates that a dataset includes a particular field, the metadatacatalog 221 can generate an annotation for the corresponding datasetconfiguration record that identifies the field as a field of thedataset, etc. In certain cases, (8) can be done before, after, orconcurrently with (7), (9), or other steps. In certain embodiments, themetadata catalog 221 generates the annotations as soon as an interactionor change occurs. In some embodiments, the metadata catalog 221 waitsuntil the query is complete before generating annotations, or generatesall annotations at a predetermined time, etc.

At (9), the query system manager 502 generates a system query and/orgroups query configuration parameters. The query configurationparameters can include the dataset configuration records 604corresponding to the primary datasets and/or the rule configurationrecords 606 corresponding to the rules associated with the query orprimary rules. In some cases, (9) can be done before, after, orconcurrently with (7), (8), (10), and the like. In certain embodiments(9) is done after (6) and before (11).

In some embodiments, the system query can be based on the user query,one or more primary or secondary datasets, the physical name of aprimary dataset(s), the dataset type of the primary dataset(s),additional query parameters identified from the datasets, and/or basedon information about the search head 504, etc. In certain embodiments,the system query corresponds to the user query modified to be compatiblewith the search head 504. For example, in some embodiments, the searchhead 504 may not be able to process one or more commands in the systemquery. Accordingly, the query system manager 502 can replace thecommands unsupported by the search head 504 with commands that aresupported by the search head 504.

In some embodiments, as the system query parses the dataset associationrecords 602 and/or dataset configuration records 604, it identifies thedatasets to be included in the query. In certain embodiments, the querysystem manager 502 identifies the datasets to be included based on thedataset identifier(s) included in the query. For example, if the queryidentifies a source dataset or source reference dataset, the querysystem manager 502 can include an identifier for the source dataset orsource reference dataset in the system query. Similarly, if the queryidentifies a single or multi-reference dataset, the query system manager502 can include an identifier for the single or multi-reference datasetin the system query and/or may include an identifier for one or more(primary) datasets referenced by the single or multi-reference datasetin the system query.

In some embodiments, the query system manager 502 identifies thedatasets to be included based on the dataset identifier(s) included inthe query and/or one or more query parameters of a dataset referenced bythe query. For example, if the query identifies (or references) a querydataset, the query system manager 502 can include the query parameters(including any referenced primary datasets) of the query dataset in thequery. As another example, the query system manager 502 can recursivelyparse the query parameters (including any referenced datasets) of thequery dataset to identify primary datasets and instructions forprocessing data from (or referenced by) the primary datasets, andinclude the identified primary datasets and instructions for processingthe data in the query. Similarly, if a query dataset references one ormore single reference or multi-reference datasets, the query systemmanager 502 can recursively process the single reference ormulti-reference datasets referenced by the query dataset until itidentifies the query parameters referenced by any dataset referenced bythe query dataset and the primary datasets that include (or reference)the data to be processed according to the identified query parameters.

In certain embodiments, the system query replaces any logical datasetidentifier of the user query (such as a query dataset) with the physicaldataset identifier of a primary dataset or source dataset identifiedfrom the metadata catalog 221. For example, if the logical name of adataset is “main” and the dataset association record 602 is “test,” thequery system manager 502 can replace “main” with “test.main” or“test_main,” as the case may be. Accordingly, the query system manager502 can generate the system query based on the physical identifier ofthe primary datasets or source datasets.

In some embodiments, the query system manager 502 generates the systemquery based on the dataset type of one or more primary datasets, sourcedatasets, or other datasets to be referenced in the system query. Forexample, datasets of different types may be interacted with usingdifferent commands and/or procedures. Accordingly, the query systemmanager 502 can include the command associated with the dataset type ofthe dataset in the query. For example, if the dataset type is an indextype, the query system manager 502 can replace a “from” command with a“search” command. Similarly, if the dataset type is a lookup type, thequery system manager 502 can replace the “from” command with a “lookup”command. As yet another example, if the dataset type is a metricsinteractions type, the query system manager 502 can replace the “from”command with an “mstats” command. As yet another example, if the datasettype is a view dataset, the query system manager 502 can replace the“from” and dataset identifier with a query identified by the viewdataset. Accordingly, in certain embodiments, the query system manager502 can generate the system query based on the dataset type of one ormore primary datasets.

In certain embodiments, the query system manager 502 does not includeidentifiers for any secondary datasets used to parse the user query. Insome cases, as the query system manager 502 parses the datasetreferenced by a query, it can determine whether a dataset associatedwith the query will be used to execute the query. If not, the datasetcan be omitted from the system query. For example, if a query datasetincludes query parameters, which reference two source datasets, thequery system manager 502 can include the query parameters andidentifiers for the two source dataset in the system query. Havingincluded the content of the query dataset in the query, the query systemmanager 502 can determine that no additional information orconfigurations from the query dataset will be used by the query or toexecute the query. Accordingly, the query system manager 502 candetermine that the query dataset is a secondary dataset and omit it fromthe query.

In some embodiments, the query system manager 502 includes only datasets(or source datasets or source reference datasets) explicitly referencedin the user query or in a query parameter of another dataset in thesystem query. For example, if the user query references a “main” sourcedataset, the “main” source dataset will only be included in the query.As another example, if the user query (or a query parameter of anotherdataset, such as a query dataset) includes a “main” source dataset and a“test” source reference dataset, only the “main” source dataset and“test” source reference dataset, will be included in the system query.However, it will be understood that the query system manager 502 can usea variety of techniques to determine whether to include a dataset in thesystem query.

In certain embodiments, the query system manager 502 can identify queryconfiguration parameters (configuration parameters associated with thequery) based on the primary datasets and/or rules associated with thequery. For example, as the query system manager 502 parses the datasetconfiguration records 604 of the datasets referenced (directly orindirectly) by the user query it can determine whether the datasetconfiguration records 604 are to be used to execute the system query.

In some cases, to determine whether the dataset configuration record 604is to be used to execute the query, the query system manager 502 canparse a generated system query. In parsing the system query, the querysystem manager 502 can determine that the datasets referenced in thesystem query will be used to execute the system query. Accordingly, thequery system manager 502 can obtain the dataset configuration records604 corresponding to the datasets referenced in the system query. Forexample, if a system query references the “test.main” dataset, the querysystem manager 502 can obtain the dataset configuration record 604 ofthe “test.main” dataset.

In addition, in some cases, the query system manager can identify anydatasets referenced by the datasets in the system query and obtain thedataset configuration records 604 of the datasets referenced by thedatasets in the system query. For example, if the system queryreferences a “users” source reference dataset, the query system manager502 can identify the source dataset referenced by the “users” sourcereference dataset and obtain the corresponding dataset configurationrecords 604, as well as the dataset configuration record 604 for the“users” source reference dataset.

In certain embodiments, the query system manager 502 can identify andobtain dataset configuration records 604 for any source dataset(s) andsource reference dataset(s) referenced (directly or indirectly) by thequery.

In some embodiments, the query system manager 502 can identify andobtain rules configurations 606 for any rules referenced by: the (systemor otherwise) query, a dataset included in the system (or othergenerated) query, a dataset for which a dataset configuration record 604is obtained as part of the query configuration parameters, and/or adataset association record referenced (directly or indirectly) by theuser query. In some cases, the query system manager 502 includes allrules associated with the dataset association record(s) associated withthe query in the query configuration parameters. In certain cases, thequery system manager 502 includes a subset of the rules associated withthe dataset a dataset association record(s) associated with the query.For example, the query system manager 502 can include rule configurationrecords 606 for only the rules referenced by or associated with adataset that is also being included in the query configurationparameters.

As described herein, the query system manager 502 can obtain the datasetconfiguration records 604 and/or rule configuration records 606 from themetadata catalog 221 based on a dynamic parsing of the user query.Accordingly, in some embodiments, the query system manager 502 candynamically identify the query configuration parameters to be used toprocess and execute the query.

At (10), the resource monitor 508 can assign a search head 504 for thequery. In some embodiments, the resource monitor 508 can dynamicallyselect a search head 504 and assign it in response to the search requestbased on a search head mapping policy. For example, based on the searchhead mapping policy, the resource monitor 508 may identify a search head504 for the query based on a current availability, responsiveness,and/or utilization rate of the search heads 504 identified in theresource catalog 510. As described herein, the resource catalog 510 caninclude metrics like concurrent search count, CPU/memory capacity, andso forth. In some embodiments, based on the search head mapping policy,the research catalog 510 may be queried to identify an available searchhead 504 with free capacity for processing the search request.

There may be numerous benefits associated with dynamically (e.g., inresponse to a request) selecting and assigning, based on availabilityand utilization, the search head 504 for the search request, instead ofusing a pre-assigned search head 504 (e.g., to specific tenants).Pre-assigning resources to tenants (or based on data identifiers) mayresult in resource utilization issues, whereas dynamically assigningsearch heads 504 can improve resource utilization by allowing for theimplementation of dynamic resource scaling based on resourceutilization. In addition, dynamically assigning search heads 504 forqueries can enable a search head 504 to be shared across tenants,thereby reducing the amount of compute resources used by the data intakeand query system 108 and increase resource utilization. For instance,when pre-assigning resources, there may be various business orimplementation rationales which dictate a maximum amount of resourcesthat can be provided to any individual tenant, as well as a minimumamount of resources that must always be allocated for each tenant.However, some tenants may require more capacity than can be staticallyreserved or assigned to them. Similarly, some tenants may beoverprovisioned resources if they request fewer searches than expected.In such cases, their provisioned search heads 504 may sit idle. Incontrast, by dynamically assigning search heads 504 for incomingqueries, available search heads 504 can be used to process searchrequests from different tenants or process queries associated withdifferent data identifiers.

At (11), the query system manager 502 communicates the system queryand/or query configuration parameters to the search head 504. Asdescribed herein, in some embodiments, the query system manager cancommunicate the system query to the search head 504. In certainembodiments, the query system manager 502 can communicate the queryconfiguration parameters to the search head 504. Accordingly, the querysystem manager 502 can communicate either the system query, the queryconfiguration parameters, or both.

In certain embodiments, by dynamically determining and communicating thequery configuration parameters to the search head 504, the query systemmanager 502 can provide a stateless search experience. For example, ifthe search head 504 becomes unavailable, the query system manager 502can communicate the dynamically determined query configurationparameters (and/or query to be executed) to another search head 504without data loss and/or with minimal or reduced time loss. Furthermore,by dynamically assigning a search head 504 to queries associated withdifferent tenants, the data intake and query system 108 can improveresource utilization and decrease resources used.

The assigned search head 504 receives and processes the query and (12)generates a search manager 514. In some embodiments, once the searchhead 504 is selected (non-limiting example: based on a search headmapping policy), the query can be forwarded to it from the resourcemonitor 508 query system manager 502, etc. As described herein, in somecases, a search master 512 can generate the search manager 514. Forexample, the search master 512 can spin up or instantiate a new process,container, or virtual machine, or copy itself to generate the searchmanager 514, etc. As described herein, in some embodiments, the searchmanager 514 can perform one or more of functions described herein withreference to FIG. 9 as being performed by the search head 504 to processand execute the query.

The search head 504 (13A) requests data identifiers from the data storecatalog 220. As described, the data store catalog 220 can includeinformation regarding the data stored in common storage 216.Accordingly, the search head 504 can query the data store catalog 220 toidentify data or buckets that include data that satisfies at least aportion of the query.

The search head 504 (13B) requests an identification of available searchnodes from the resource monitor 508 and/or resource catalog 510. Asdescribed herein, the resource catalog 510 can include informationregarding the search nodes 506 of the query system 214. The search head504 can either directly query the resource catalog 510 in order toidentify a number of search nodes available to execute the query, or thesearch head 504 may send a request to the resource monitor 508, whichwill identify a number of search nodes available to execute the query byconsulting the resource catalog 510. In some cases, the (13A) and (13B)requests can be done concurrently or in any order.

In some cases, the search head 504 requests a search node assignmentbased on a search node mapping policy. The search node mapping policycan use any one or any combination of data identifiers associated withthe query, search node identifiers, priority levels, etc. to indicatehow search nodes 506 should be assigned for a query. In some cases,based on the search node mapping policy, the search head 504 requests asearch node assignment for the query. In some such cases, the searchhead 504 can include the data identifier associated with the query inits request for a search node assignment.

At (14A), the data store catalog 220 provides the search head 504 withan identification of data that satisfies at least a portion of thequery. As described herein, in response to the request from the searchhead 504, the data store catalog 220 can be used to identify and returnidentifiers of buckets in common storage 216 and/or location informationof data in common storage 216 that satisfy at least a portion of thequery or at least some filter criteria (e.g., buckets associated with anidentified tenant or partition or that satisfy an identified time range,etc.).

In some cases, as the data store catalog 220 can routinely receiveupdates by the indexing system 212, it can implement a read-write lockwhile it is being queried by the search head 504. Furthermore, the datastore catalog 220 can store information regarding which buckets wereidentified for the search. In this way, the data store catalog 220 canbe used by the indexing system 212 to determine which buckets in commonstorage 216 can be removed or deleted as part of a merge operation.

At (14B), the resource catalog 510 (or the resource monitor 508, byconsulting the resource catalog 510) provides the search head 504 with asearch node assignment and/or an identification of available searchnodes 506. As described herein, in response to the request from thesearch head 504, the resource catalog 510 and/or the resource monitor508 can be used to identify and return identifiers for search nodes 506that are available to execute the query. In some embodiments, theresource monitor 508 or resource catalog 510 determines the search nodeassignment based on a search node mapping policy, which can include asearch head-node mapping policy. As described herein, the search nodeassignment can be based on numerous factors, including the availabilityand utilization of each search node 506, a data identifier associatedwith the query, search node identifiers, etc.

There may be numerous benefits associated with dynamically (e.g., inresponse to a request) selecting and assigning the search nodes 506 forexecuting the query, in a manner that factors in availability andutilization rather than relying on pre-assigned search nodes (e.g., tospecific tenants). Pre-assigning resources to tenants may result inresource utilization issues, whereas dynamically assigning search nodes506 can improve resource utilization by allowing for the implementationof dynamic resource scaling based on resource utilization, as previouslymentioned, and also enabling search nodes to be shared across tenantsand allocated based on demand. For instance, when pre-assigningresources, there may be various business or implementation rationaleswhich dictate a maximum amount of resources that can be provided to anyindividual tenant, as well as a minimum amount of resources that mustalways be allocated for each tenant. However, some tenants may requiremore capacity than statically provided to them. Or, there may beoverprovisioning if some tenants do not request any searches, since thesearch nodes 506 assigned to those tenants may sit idle. In contrast,under dynamic assignment, search nodes 506 can be selected based onavailability and shared between tenants to execute queries.

As previously discussed, the search head-node mapping policy may alsoconsider additional factors beyond availability and utilization of thedifferent search nodes. For instance, the total number of search nodes506 being assigned to execute the query can vary and be determinedduring assignment of search nodes 506, such that the maximum number ofsearch nodes 506 being assigned is dynamic. The number of search nodes506 being assigned can be based on a static configuration, based on analgorithm run at the time the search nodes are being identified, and soforth. For instance, there may be a global static configuration (e.g.,always return X number of search nodes 506 in this scenario). Or theremay be a data identifier-specific static configuration (e.g., return atleast or no more than X number of search nodes 506 if the search requestis associated with tenant Y), such that the number of search nodes 506to assign to the search head 504 for executing the query may bepreconfigured based on the data identifier associated with the query(non-limiting example, a tenant identifier associated with the query).Alternatively, the number of search nodes 506 being assigned may bespecified in the query, either as an absolute number of search nodes(e.g., X number of search nodes), as a percentage of resources (e.g.,20% of the total number of search nodes or 20% of the number of searchnodes with sufficient capacity), and so forth. Thus, the resourcemonitor 508 and/or the resource catalog 510 may wait until there are asufficient number of search nodes 506 with availability that meets therequested number of search nodes 506 before assigning those search nodes506 to execute the query, or the resource monitor 508 and/or theresource catalog 510 may have additional search nodes 506 spun up tomeet the required number of search demands.

Furthermore, since data identifiers, such as tenant identifiers, aremapped to search nodes 506, similar queries for a specific tenant may beassociated with data stored in similar sets of buckets. In other words,some of the data for a specific tenant may reside in a local or shareddata store between search nodes 506 from an earlier query (e.g., thesearch nodes 506), and it may be desirable to assign additional queriesfor that tenant to those search nodes (e.g., the search nodes 506).Thus, the search head-node mapping policy may additionally attempt torepeatedly choose, for a specific tenant, the same search nodes 506 oras many of the same search nodes as possible that were used for previousqueries for that tenant in order to take advantage of caching. Forexample, if the query system 214 receives two queries associated with aspecific tenant and the same number of search nodes 506 are to be usedfor both queries, the same search nodes 506 can be assigned to the firstquery and the second query (either concurrently or consecutively).However, if the set of available search nodes 506 has changed betweenthe two queries, then the search head-node mapping policy may indicatethat a minimum amount of different search nodes 506 should be introducedfor the second query. This affinity for using the same search nodes 506can exist even when the search head 504 changes. For example, queriesassociated with the same data identifier can be assigned to variousdifferent search heads 504, but the same search nodes 506 or similarsearch nodes 506 (e.g., used in previous queries) can be used with thedifferent search heads 504.

As described herein, in some embodiments, using a consistent hashingalgorithm, the query system 214 can increase the likelihood that thesame search nodes 506 will be used to execute queries associated withthe same data identifiers. For example, as described herein, a hash canbe performed on a tenant identifier associated with the tenantrequesting the search, and the output of the hash can be used toidentify the search nodes 506 assigned to that tenant to use for thequery. In some implementations, the hash may be a consistent hash or usea hash ring, to increase the likelihood that the same search nodes 506are selected for the queries associated with the same data identifier.In some cases, the consistent hash function can be configured such thateven with a different number of search nodes 506 being assigned toexecute the query, the output can consistently identify some of the samesearch nodes 506 to execute the query, or have an increased probabilityof identifying some of the same search nodes 506 for the query.

In some embodiments, all the search nodes 506 may be mapped out tovarious different tenants (e.g., using tenant identifiers), such thateach search node 506 can be mapped to one or more specific tenants.Thus, in certain embodiments, a specific tenant can have a group of oneor more search nodes 506 assigned to it.

At (15) the search head 504 maps the identified search nodes 506 to thedata according to a search node mapping policy, which can include asearch node-data mapping policy. In some cases, per the search node-datamapping policy, the search head 504 can dynamically map search nodes 506to the identified data or buckets. As described herein, the search head504 can map the identified search nodes 506 to the identified data orbuckets at one time or iteratively as the buckets are searched accordingto the search node-data mapping policy. In certain embodiments, per thesearch node-data mapping policy, the search head 504 can map theidentified search nodes 506 to the identified data based on previousassignments, data stored in a local or shared data store of one or moresearch heads 504, network architecture of the search nodes 506, ahashing algorithm, etc.

In some cases, as some of the data may reside in a local or shared datastore between the search nodes 506, the search head 504 can attempt tomap that was previously assigned to a search node 506 to the same searchnode 506. In certain embodiments, to map the data to the search nodes506, the search head 504 uses the identifiers, such as bucketidentifiers, received from the data store catalog 220. In someembodiments, the search head 504 performs a hash function to map abucket identifier to a search node 506. In some cases, the search head504 uses a consistent hash algorithm, similar to a consistent hashingused to assign search nodes 506 to queries using a data identifier, toincrease the probability of mapping a bucket identifier to the samesearch node 506.

In certain embodiments, the search head 504 or query system 214 canmaintain a table or list of bucket mappings to search nodes 506. In suchembodiments, per the search node-data mapping policy, the search head504 can use the mapping to identify previous assignments between searchnodes and buckets. If a particular bucket identifier has not beenassigned to a search node 506, the search head 504 can use a hashalgorithm to assign it to a search node 506. In certain embodiments,prior to using the mapping for a particular bucket, the search head 504can confirm that the search node 506 that was previously assigned to theparticular bucket is available for the query. In some embodiments, ifthe search node 506 is not available for the query, the search head 504can determine whether another search node 506 that shares a data storewith the unavailable search node 506 is available for the query. If thesearch head 504 determines that an available search node 506 shares adata store with the unavailable search node 506, the search head 504 canassign the identified available search node 506 to the bucket identifierthat was previously assigned to the now unavailable search node 506.

At (16), the search head 504 instructs the search nodes 506 to executethe query. As described herein, based on the assignment of buckets tothe search nodes 506, the search head 504 can generate searchinstructions for each of the assigned search nodes 506. Theseinstructions can be in various forms, including, but not limited to,JSON, DAG, etc. In some cases, the search head 504 can generatesub-queries for the search nodes 506. Each sub-query or instructions fora particular search node 506 generated for the search nodes 506 canidentify any one or any combination of: the buckets that are to besearched, the filter criteria to identify a subset of the set of data tobe processed, and the manner of processing the subset of data, etc.Accordingly, the instructions can provide the search nodes 506 with therelevant information to execute their particular portion of the query.

At (17), the search nodes 506 obtain the data to be searched. Asdescribed herein, in some cases the data to be searched can be stored onone or more local or shared data stores of the search nodes 506. In someembodiments, the data to be searched is located in the intake system 210and/or the acceleration data store 222. In certain embodiments, the datato be searched is located in the common storage 216. In suchembodiments, the search nodes 506 or a cache manager 516 can obtain thedata from the common storage 216.

In some cases, the cache manager 516 can identify or obtain the datarequested by the search nodes 506. For example, if the requested data isstored on the local or shared data store of the search nodes 506, thecache manager 516 can identify the location of the data for the searchnodes 506. If the requested data is stored in common storage 216, thecache manager 516 can obtain the data from the common storage 216. Asanother example, if the requested data is stored in the intake system210 and/or the acceleration data store 222, the cache manager 516 canobtain the data from the intake system 210 and/or the acceleration datastore 222.

As described herein, in some embodiments, the cache manager 516 canobtain a subset of the files associated with the bucket to be searchedby the search nodes 506. For example, based on the query, the searchnode 506 can determine that a subset of the files of a bucket are to beused to execute the query. Accordingly, the search node 506 can requestthe subset of files, as opposed to all files of the bucket. The cachemanager 516 can download the subset of files from common storage 216 andprovide them to the search node 506 for searching.

In some embodiments, such as when a search node 506 cannot uniquelyidentify the file of a bucket to be searched, the cache manager 516 candownload a bucket summary or manifest that identifies the filesassociated with the bucket. The search node 506 can use the bucketsummary or manifest to uniquely identify the file to be used in thequery. The common storage 216 can then obtain that uniquely identifiedfile from common storage 216.

At (18), the search nodes 506 search and process the data. As describedherein, the sub-queries or instructions received from the search head504 can instruct the search nodes 506 to identify data within one ormore buckets and perform one or more transformations on the data.Accordingly, each search node 506 can identify a subset of the set ofdata to be processed and process the subset of data according to thereceived instructions. This can include searching the contents of one ormore inverted indexes of a bucket or the raw machine data or events of abucket, etc. In some embodiments, based on the query or sub-query, asearch node 506 can perform one or more transformations on the datareceived from each bucket or on aggregate data from the differentbuckets that are searched by the search node 506.

At (19), the search head 504 monitors the status of the query of thesearch nodes 506. As described herein, the search nodes 506 can becomeunresponsive or fail for a variety of reasons (e.g., network failure,error, high utilization rate, etc.). Accordingly, during execution ofthe query, the search head 504 can monitor the responsiveness andavailability of the search nodes 506. In some cases, this can be done bypinging or querying the search nodes 506, establishing a persistentcommunication link with the search nodes 506, or receiving statusupdates from the search nodes 506 (non-limiting example: the“heartbeat”). In some cases, the status can indicate the buckets thathave been searched by the search nodes 506, the number or percentage ofremaining buckets to be searched, the percentage of the query that hasbeen executed by the search node 506, etc. In some cases, based on adetermination that a search node 506 has become unresponsive, the searchhead 504 can assign a different search node 506 to complete the portionof the query assigned to the unresponsive search node 506.

In certain embodiments, depending on the status of the search nodes 506,the search manager 514 can dynamically assign or re-assign buckets tosearch nodes 506. For example, as search nodes 506 complete their searchof buckets assigned to them, the search manager 514 can assignadditional buckets for search. As yet another example, if one searchnode 506 is 95% complete with its search while another search node 506is less than 50% complete, the query manager can dynamically assignadditional buckets to the search node 506 that is 95% complete orre-assign buckets from the search node 506 that is less than 50%complete to the search node that is 95% complete. In this way, thesearch manager 514 can improve the efficiency of how a computing systemperforms searches through the search manager 514 increasingparallelization of searching and decreasing the search time.

At (20), the search nodes 506 send individual query results to thesearch head 504. As described herein, the search nodes 506 can send thequery results as they are obtained from the buckets and/or send theresults once they are completed by a search node 506. In someembodiments, as the search head 504 receives results from individualsearch nodes 506, it can track the progress of the query. For example,the search head 504 can track which buckets have been searched by thesearch nodes 506. Accordingly, in the event a search node 506 becomesunresponsive or fails, the search head 504 can assign a different searchnode 506 to complete the portion of the query assigned to theunresponsive search node 506. By tracking the buckets that have beensearched by the search nodes and instructing different search node 506to continue searching where the unresponsive search node 506 left off,the search head 504 can reduce the delay caused by a search node 506becoming unresponsive, and can aid in providing a stateless searchingservice.

At (21), the search head 504 processes the results from the search nodes506. As described herein, the search head 504 can perform one or moretransformations on the data received from the search nodes 506. Forexample, some queries can include transformations that cannot becompleted until the data is aggregated from the different search nodes506. In some embodiments, the search head 504 can perform thesetransformations.

At (22A), the search head 504 communicates or stores results in thequery acceleration data store 222. As described herein, in some casessome, all, or a copy of the results of the query can be stored in thequery acceleration data store 222. The results stored in the queryacceleration data store 222 can be combined with other results alreadystored in the query acceleration data store 222 and/or be combined withsubsequent results. For example, in some cases, the query system 214 canreceive ongoing queries, or queries that do not have a predetermined endtime. In such cases, as the search head 504 receives a first set ofresults, it can store the first set of results in the query accelerationdata store 222. As subsequent results are received, the search head 504can add them to the first set of results, and so forth. In this way,rather than executing the same or similar query data across increasinglylarger time ranges, the query system 214 can execute the query across afirst time range and then aggregate the results of the query with theresults of the query across the second time range. In this way, thequery system can reduce the amount of queries and the size of queriesbeing executed and can provide query results in a more time efficientmanner. At (22B), the search head 504 communicates the results to themetadata catalog 221. In some cases, (22A) and (22B) can be doneconcurrently.

At (23), the metadata catalog 221 generates annotations. As mentioned,the metadata catalog 221 can generate annotations each time changes aremade to it. Accordingly, based on the receipt of the query results, themetadata catalog 221 can generate annotations that include the queryresults. As described herein, in some cases, query results can be storedin the metadata catalog 221. In some such embodiments, the query resultscan be accessed at a later time without re-executing the query. In thisway, the data intake and query system can reduce the compute resourcesused. In certain embodiments, the metadata catalog 221 can generateannotations based on the content of the query results. For example, ifthe query results identify one or more fields associated with a dataset,the metadata catalog 221 can generate annotations for the correspondingdataset configuration record that identify the fields of the dataset,etc. Further, the results may result in additional annotations to otherqueries, etc.

At (24), the search head 504 terminates the search manager 514. Asdescribed herein, in some embodiments a search head 504 or a searchmaster 512 can generate a search manager 514 for each query assigned tothe search head 504. Accordingly, in some embodiments, upon completionof a search, the search head 504 or search master 512 can terminate thesearch manager 514. In certain embodiments, rather than terminating thesearch manager 514 upon completion of a query, the search head 504 canassign the search manager 514 to a new query. In some cases, (24) can beperformed before, after, or concurrently with (23).

As mentioned previously, in some of embodiments, one or more of thefunctions described herein with respect to FIG. 9 can be omitted,performed in a variety of orders and/or performed by a differentcomponent of the data intake and query system 108. For example, thesearch head 504 can monitor the status of the query throughout itsexecution by the search nodes 506 (e.g., during (17), (18), and (20)).Similarly, (1), (2), (3A), (3B), and (4), can be performed concurrentlywith each other and/or with any of the other steps. In some cases, arebeing performed consistently or repeatedly. Steps (13A) and (13B) andsteps (14A) and (14B) can be performed before, after, or concurrentlywith each other. Further, (13A) and (14A) can be performed before,after, or concurrently with (14A) and (14B). As yet another example,(17), (18), and (20) can be performed concurrently. For example, asearch node 506 can concurrently receive one or more files for onebucket, while searching the content of one or more files of a secondbucket and sending query results for a third bucket to the search head504. Similarly, the search head 504 can (15) map search nodes 506 tobuckets while concurrently (15) generating instructions for andinstructing other search nodes 506 to begin execution of the query. Insome cases, such as when the set of data is from the intake system 210or the acceleration data store 222, (13A) and (14A) can be omitted.Furthermore, in some such cases, the data may be obtained (17) from theintake system 210 and/or the acceleration data store 222.

In some embodiments, such as when one or more search heads 504 and/orsearch nodes 506 are statically assigned to queries associated to atenant and/or with a particular data identifier, (3A), (3B), (7), and(10) may be omitted. For example, in some such embodiments, there mayonly be one search head 504 associated with the data identifier ortenant. As such, the query system 214 may not dynamically assign asearch head 504 for the query. In certain embodiments, even where searchheads 504 and/or search nodes 506 are statically assigned to a tenant ora data identifier, (3A), (3B), (7), and (10) may be used to determinewhich of multiple search heads 504 assigned to the tenant or dataidentifier is to be used for the query, etc.

In certain embodiments, the query system can use multiple sub-policiesof a search node mapping policy to identify search nodes for a queryand/or to process data. For example, the query system 214 may use asearch head-node mapping policy to identify search nodes 506 to use inthe query and/or may use a search node-data policy to determine which ofthe assigned search nodes 506 is to be used to process certain data ofthe query. In some cases, the search node mapping policy may onlyinclude a search head-node mapping policy or a search node-data policyto identify search nodes 506 for the query, etc. Moreover, it will beunderstood that any one or any combination of the components of thequery system 214 can be used to implement a search node mapping policy.For example, the resource monitor 508 or search head 504 can implementthe search node mapping policy, or different portions of the search nodemapping policy, as desired.

4.3.1. Example Metadata Catalog Processing

FIG. 10 is a data flow diagram illustrating an embodiment of the dataflow for identifying primary datasets, secondary datasets, and queryconfiguration parameters for a particular query 1002. In the illustratedembodiment, the query system manager 502 receives the query 1002, whichincludes the following query parameters “|from threats-encountered|sort-count|head 10.” In addition, “trafficTeam” is identified as theidentifier of a dataset association record 602N associated with thequery 1002.

Based on the identification of “trafficTeam” as the dataset associationrecord identifier, the query system manager 502 (1) determines that the“trafficTeam” dataset association record 602N is associated with thequery, is to be searched, and/or determines a portion of the physicalname for datasets (or dataset configuration records 604) to be searched.

In addition, based on the query 1002, the query system manager 502identifies “threats-encountered” as a logical dataset identifier. Forexample, the query system manager 502 can determine that a datasetidentifier follows the “from” command. Accordingly, at (2), the querysystem manager 502 parses the “threats-encountered” dataset 608I (orassociated dataset configuration record 604). As part of parsing the“threats-encountered” dataset 608I, the query system manager 502determines that the “threats-encountered” dataset 608I is amulti-reference query dataset that references two additional datasets608J and 608H (“traffic” and “threats”). In some embodiments, the querysystem manager 502 can identify the related datasets 608J and 608H basedon a system annotation in the dataset configuration record 604N and/orbased on parsing the query of the dataset configuration record 604N.Based on the identification of the additional datasets, the query systemmanager 502 parses the “traffic” dataset 608J and the “threats” dataset608H (or associated dataset configuration record 604) at (3A) and (3B),respectively. Based on parsing the “threats” dataset 608H (orassociation dataset configuration record 604), the query system manager502 determines that the “threats” dataset 608H is a single sourcereference dataset that references or relies on the “threats-col” dataset608G. In certain cases, the query system manager 502 can identify the“threats-col” dataset 608G based on an annotation in the datasetconfiguration record 604 associated with the “threats” dataset 608H.Accordingly, at (4A) query system manager 502 parses the “threats-col”dataset 608G (or associated dataset configuration record 604). Based onparsing the “threats-col” dataset 608G, the query system manager 502determines that the “threats-col” dataset 608G is a non-referentialsource dataset.

Based on parsing the “traffic” dataset 608J, the query system manager502 determines that the “traffic” dataset 608J is an imported datasetthat corresponds to the “main” dataset 608A of the “shared” datasetassociation record 602A, which may also be referred to as the“shared.main” dataset 608A. In some cases, the query system manager 502can identify the “shared.main” dataset 608A based on the definition ofthe “traffic” dataset 608J in the dataset association record 602N orbased on an annotation in a dataset configuration record 604 associatedwith the dataset “traffic” 608H. Accordingly, at (4B), the query systemmanager 502 parses the “shared.main” dataset 608A (or associated datasetconfiguration record 604). Based on parsing the “shared.main” dataset608A, the query system manager 502 determines that the “shared.main”dataset 608A is a non-referential source dataset. In some embodiments,based on parsing the “shared.main” dataset 608A, the query systemmanager 502 can determine that the rule “shared.X” 610A is related tothe “shared.main” dataset 608A and begin parsing the rule “shared.X”610A based on the identification. This may be done in place of orconcurrently with step (4C) and (5) described below.

As part of parsing the “traffic” dataset 608J, the query system manager502 also determines that the “shared.X” rule 610B is associated with the“traffic” dataset 608J (e.g., based on its presence in the datasetassociation record 602N and/or based on another indication of arelationship, such as an annotation in a rule configuration record 606for the “shared.X” rule 610B or an annotation in a dataset configurationrecord 604 for the “shared.main” dataset 608A), and at (4C), parses the“shared.X” rule 610B (which may include parsing the rule configurationrecord 606 of the “shared.X” rule 610B). Based on parsing the “shared.X”rule 610B, the query system manager 502 determines that the “shared.X”rule 610B is imported from the “shared” dataset association record 602Aand at (5) parses the “X” rule 610A of the dataset association record602A. Based on parsing the “X” rule 610A (or associated ruleconfiguration record 606), the query system manager 502 determines thatthe “X” rule 610A references the “users” dataset 608C, and at (6) parsesthe “users” dataset 608C (or associated dataset configuration record604). Based on parsing the “users” dataset 608C, the query systemmanager 502 determines that the “users” dataset 608C references the“users-col” dataset 608D and at (7) parses the “users-col” dataset 608D.Based on parsing the “users-col” dataset 608D, the query system manager502 determines that the “users-col” dataset 608D is a non-referentialsource dataset.

In some embodiments, each time the query system manager 502 identifies anew dataset, it can identify the dataset as a dataset associated withthe query. As the query system manager 502 processes the dataset, it candetermine whether the dataset is a primary dataset or a secondarydataset. For example, if a view dataset merely references other datasetsor includes additional query parameters and the configurations of theview dataset will not be used (or needed) to execute the queryparameters or access the referenced datasets, it can be identified as asecondary dataset and omitted as a primary dataset. With reference tothe illustrated embodiment, the query system manager 502 may identify“threats-encountered” dataset 608I as being associated with the querybased on its presence in the user query 1002. However, once the querysystem manager 502 determines that the “threats-encountered” dataset608I adds additional query parameters to the query 1002, but does notinclude data and/or will not be used to execute the query, it canidentify the “threats-encountered” dataset 608I as secondary dataset butnot a primary dataset (and may or may not keep the query parameters).

As described herein, in some cases, the query system manager 502determines the physical names of the primary datasets based on datasetassociation records 602A, 602N. For example, the query system manager502 can use the names or identifiers of the dataset association records602A, 602N to determine the physical names of the primary datasetsand/or rules associated with the query. Using the physical names of theprimary datasets and/or rules associated with the query, the querysystem manager 502 (8) identifies the dataset configuration records 604from various dataset configuration records 604 and rule configurationrecords 606 from various rule configuration records 606 for inclusion asquery configuration parameters 1006. In some embodiments, the querysystem manager 502 can determine the dataset types of the primarydatasets and other query configuration parameters associated with theprimary datasets and rules associated with the query using the datasetconfiguration records 604 and rule configuration records 606.

In the illustrated embodiment, the query system manager 502 candetermine that the datasets 608B, 608E, and 608F are not datasetsassociated with the query as they were not referenced (directly orindirectly) by the query 1002. Conversely, in the illustratedembodiment, the query system manager 502 determines that datasets 608A,608C, 608D, 608G, 608H, 608I, and 608J are datasets associated with thequery as they were referenced (directly or indirectly) by the query1002.

In addition, in the illustrated embodiment, the query system manager 502determines that the “shared.main,” “shared.users,” “shared.users-col,”“trafficTeam.threats,” and “trafficTeam.threat-col” datasets 608A, 608C,608D, 608H, 608G, respectively, are primary datasets as they will beused to execute or process the system query 1004 and that the“trafficTeam.threats-encountered” dataset 608I and “trafficTeam.traffic”dataset 608J are secondary datasets as they will not be used toprocess/execute the query. Moreover, the query system manager 502determines that the rule “shared.X” is associated with the query and/orwill be used to process/execute the system query.

As mentioned, although, the “threats-encountered” and “traffic” datasets608I, 608J, respectively, were identified as part of the processing, thequery system manager 502 determines not to include them as primarydatasets as they are not source datasets or will not be used to executethe system query. Rather, the “threats-encountered” and “traffic”datasets 608I, 608J were used to identify other datasets and queryparameters. For example, the “threats-encountered” dataset 608I is aview dataset that includes additional query parameters that referencetwo other datasets, and the “traffic” dataset 608J is merely the name ofthe “shared.main” dataset 608A imported into the “trafficTeam” datasetassociation record 602N.

Based on the acquired information, the query system manager 502 (9)generates the system query 1004 and/or the query configurationparameters 1006 for the query. With reference to the system query 1004,the query system manager 502 has included query parameters identifiedfrom the “threats-encountered dataset” in the system query 1004 andreplaced the logical identifiers of datasets in the query with physicalidentifiers of the datasets (e.g., replaced “threats-encountered” with“shared.main” and “trafficTeam.threats”). In addition, the query systemmanager 502 includes commands specific to the dataset type of thedatasets in the query (e.g., “from” replaced with “search” for the“shared.main” dataset 608A and “lookup” included for the lookup“trafficTeam.threats” dataset 608H). Accordingly, the system query 1004is configured to be communicated to the search head 504 for processingand execution.

Moreover, based on the information from the metadata catalog 221, thequery system manager 502 is able to generate the query configurationparameters 1006 for the query to be executed by the data intake andquery system 108. In some embodiments, the query configurationparameters 1006 include dataset configuration records 604 (or portionsthereof) associated with: datasets identified in the query 1004,datasets referenced by the datasets identified in the query 1004, and/ordatasets referenced by a rule or rule configuration record 606 included(or identified for inclusion) in the query configuration parameters1006. In certain embodiments, the query configuration parameters 1006include dataset configuration records 604 (or portions thereof)associated with the primary datasets. In some cases, when includingdataset configuration records 604, the query system manager 502 may omitcertain portions of the dataset configuration records 604. For example,the query system manager 502 may omit one or more annotations, such asthe annotations identifying relationships between datasets or fields,etc. In certain embodiments, the query system manager 502 includes areference to the various dataset configuration records 604 rather than acopy of the dataset configuration records 604.

In some embodiments, the query configuration parameters 1006 includesrule configuration records 606 of rules associated with: the query(referenced directly or indirectly), datasets identified in the query1004, and/or datasets (or dataset configuration records 604) identifiedin the query configuration parameters 1006.

In some cases, the query system manager 502 can iteratively identifydataset configuration records 604 and/or rules configurations 606 forinclusion in the query configuration parameters 1006. As a non-limitingexample, the query system manager 502 can include a first datasetconfiguration record 604 in the query configuration parameters 1006(e.g., of a dataset referenced in the query to be executed). The querysystem manager 502 can then include dataset configuration records 604 orrule configuration records 606 of any datasets referenced by the firstdataset (or corresponding configuration 604). The query system manager502 can iteratively include dataset and rule configuration records 604,606 corresponding to datasets or rules referenced by an already includedrule or dataset (or corresponding configurations 604, 606) until therelevant dataset and rule configuration records 606 are included in thequery configuration parameters 1006. In certain embodiments, onlyconfigurations corresponding to primary datasets and primary rules areincluded in the query configuration parameters 1006. Less or additionalinformation or configurations can be included in the query configurationparameters 1006.

As another non-limiting example and with reference to the illustratedembodiment, the query system manager 502 can include the “shared.main”dataset configuration record 604 and “trafficTeam.threats” datasetconfiguration record 604 in the query configuration parameters 1006based on their presence in the query 1004. Based on a determination thatthe “trafficTeam.threats-col” dataset configuration record 604 isreferenced by the “trafficTeam.threats” dataset (or correspondingconfiguration 604), the query system manager 502 can include the“trafficTeam.threats-col” dataset configuration record 604 in the queryconfiguration parameters 1006.

Based on a determination that the “shared.X” rule is referenced by the“shared.main” dataset 608A or a determination that the “shared.X” ruleis included in the dataset association record 602N, the query systemmanager 502 can include the “shared.X” rule configuration record 606 inthe query configuration parameters 1006. Furthermore, based on adetermination that the “shared.users” dataset 608C is referenced by the“shared.X” rule (inclusive of any action of the “shared.X” rule orcorresponding configuration 606), the query system manager 502 caninclude the “shared.users” dataset 608C in the query configurationparameters 1006. Similarly, the query system manager 502 can include the“shared.users-col” dataset 608D in the query configuration parameters1006 based on a determination that it is referenced by the“shared.users” dataset 608C.

In the illustrated embodiment, the query system manager 502 determinesthat the datasets “shared.main,” “shared.users,” “shared.users-col,”“trafficTeam.threats,” and “trafficTeam.threat-col” are primarydatasets. Accordingly, the query system manager 502 includes the datasetconfiguration records 604 corresponding to the identified primarydatasets as part of the query configuration parameters 1006. Similarly,the query system manager 502 determines that the “shared.X” rule isassociated with the query and/or will be used to process/execute thequery and includes the corresponding rule configuration record 606 aspart of the query configuration parameters 1006.

In the illustrated embodiment, the query to be executed by the dataintake and query system 108 corresponds to the system query 1004,however, it will be understood that in other embodiments, the querysystem manager 502 may identify the query configuration parameters 1006for the query and may not translate the user query to the system query1004. Thus, the query configuration parameters 1006 can be used toexecute a system query, a user query, or some other query generated fromthe user query 1002.

As mentioned, in some embodiments, the metadata catalog 221 may notstore separate dataset association records 602. Rather, the datasetsassociation records 602 illustrated in FIG. 10 can be considered alogical association between one or more dataset configuration records604 and/or one or more rule configuration records 606. In certainembodiments, the datasets 608 and/or rules 610 of each datasetassociation record 602 may be references to dataset configurationrecords 604 and/or rule configuration records 606. Accordingly, in someembodiments, rather than moving from or parsing different portions of adataset association record 602, it will be understood that the querysystem manager 502 can parse different dataset configuration records 604and/or rule configuration records 606 based on the identified physicalidentifier for the dataset or rule. For example, (2) may refer toparsing the “trafficTeam.threats-encountered” dataset configurationrecord 604, (3A) and (3B) may refer to parsing the “trafficTeam.traffic”and “trafficTeam.threats” dataset configuration records 604,respectively, (4A) and (4B) may refer to parsing the“trafficTeam.threats-col” and “shared.main,” dataset configurationrecords 604, respectively, (4C) may refer to parsing the“trafficTeam.shared.X” (or “shared.X”) rule configuration record 606,(5) may refer to parsing the “shared.X” rule configuration record 606(or be combined with (4C)), (6) may refer to parsing the “shared.users”dataset configuration record 604, and (7) may refer to parsing the“shared.users-col” dataset configuration record 604. Thus, as the querysystem manager 502 parses different datasets 608 or rules 610, it can doso using the dataset configuration records 604 and rule configurationrecords 606, respectively. Moreover, in some such embodiments (8) may beomitted (or considered as part of each parsing step) as the query systemmanager 502 references the relevant dataset configuration records 604and rule configuration records 606 throughout the review or parsingprocess. Based on the review of the various dataset configurationrecords 604 and rule configuration records 606, the query system manager502 can (9) generate the system query 1004 and/or the queryconfiguration parameters 1006.

Furthermore, when parsing the dataset configuration records 604 or ruleconfiguration records 606, the system can use one or more annotations toidentify related datasets. For example, the system can determine thatthe “threats-encountered” dataset 608I depends on and/or is related tothe “traffic” dataset 608J and “threats” dataset 608H based on one ormore annotations, such as an inter-dataset relationship annotation, inthe dataset configuration record 604N. In some embodiments, using theannotations in the dataset configuration records 604, the system canmore quickly traverse between the different datasets and identify theprimary datasets for the query 1002.

In certain embodiments, as the system parses the query 1002, it canextract metadata and generate additional annotations for one or moredataset configuration records 604 and rule configuration records 606.For example, the query 1002 can be referred to as a dataset “job.” Basedon its reference to “threats-encountered,” the system can determine thatthe dataset “job” is dependent on “threats-encountered” and generate anannotation based on the determined relationship. The system can generateone or more additional annotations for the dataset “job” as describedherein. In some embodiments the annotations can be stored for future useor reference. For example, for each query that is entered, the systemcan generate a dataset configuration record 606 and store theannotations generated for the query.

In addition, if the system has not already generated annotations forother datasets referenced by the query (e.g., when the various datasetsare added to the metadata catalog 221), then the system can generateannotations as it traverses the datasets as part of parsing the query1002. For example, as described herein, the system can generateannotations for the dataset configuration record 604N indicating thatthe “threats-encountered” dataset 608I is dependent on the “traffic” and“threats” datasets 608H, 608J, respectively. As also described herein,the system can determine a relationship between the field “sig” of the“traffic” dataset 608J and the field “sig” of the “threats” dataset608H. Likewise, the system can determine inter-dataset relationshipsbetween the “traffic” and “main” datasets 608J and 608A, the“threats-col” and “threats” datasets 608G and 608H, and the “users” and“users-col” datasets 608C and 608D. In a similar way, the system candetermine a rule-dataset relationship between rule “X” 610A and dataset“users” 608C, etc. The system can use the various determinedrelationships to generate annotations for corresponding dataset and ruleconfiguration records 604, 606, respectively. In some embodiments, thegenerated annotations can be used to more efficiently parse and executethe query if it is executed again, to generate suggestions for the user,and/or to enable the user to gain a greater understanding of the dataassociated with, stored by, or managed by the system.

4.4. Data Ingestion, Indexing, and Storage Flow

FIG. 11A is a flow diagram of an example method that illustrates how adata intake and query system 108 processes, indexes, and stores datareceived from data sources 202, in accordance with example embodiments.The data flow illustrated in FIG. 11A is provided for illustrativepurposes only; it will be understood that one or more of the steps ofthe processes illustrated in FIG. 11A may be removed or that theordering of the steps may be changed. Furthermore, for the purposes ofillustrating a clear example, one or more particular system componentsare described in the context of performing various operations duringeach of the data flow stages. For example, the intake system 210 isdescribed as receiving and processing machine data during an inputphase; the indexing system 212 is described as parsing and indexingmachine data during parsing and indexing phases; and a query system 214is described as performing a search query during a search phase.However, other system arrangements and distributions of the processingsteps across system components may be used.

4.4.1. Input

At block 1102, the intake system 210 receives data from an input source,such as a data source 202 shown in FIG. 2. The intake system 210initially may receive the data as a raw data stream generated by theinput source. For example, the intake system 210 may receive a datastream from a log file generated by an application server, from a streamof network data from a network device, or from any other source of data.In some embodiments, the intake system 210 receives the raw data and maysegment the data stream into messages, possibly of a uniform data size,to facilitate subsequent processing steps. The intake system 210 maythereafter process the messages in accordance with one or more rules, asdiscussed above for example with reference to FIGS. 7 and 8, to conductpreliminary processing of the data. In one embodiment, the processingconducted by the intake system 210 may be used to indicate one or moremetadata fields applicable to each message. For example, the intakesystem 210 may include metadata fields within the messages, or publishthe messages to topics indicative of a metadata field. These metadatafields may, for example, provide information related to a message as awhole and may apply to each event that is subsequently derived from thedata in the message. For example, the metadata fields may includeseparate fields specifying each of a host, a source, and a source typerelated to the message. A host field may contain a value identifying ahost name or IP address of a device that generated the data. A sourcefield may contain a value identifying a source of the data, such as apathname of a file or a protocol and port related to received networkdata. A source type field may contain a value specifying a particularsource type label for the data. Additional metadata fields may also beincluded during the input phase, such as a character encoding of thedata, if known, and possibly other values that provide informationrelevant to later processing steps.

At block 504, the intake system 210 publishes the data as messages on anoutput ingestion buffer 310. Illustratively, other components of thedata intake and query system 108 may be configured to subscribe tovarious topics on the output ingestion buffer 310, thus receiving thedata of the messages when published to the buffer 310.

4.4.2. PARSING

At block 1106, the indexing system 212 receives messages from the intakesystem 210 (e.g., by obtaining the messages from the output ingestionbuffer 310) and parses the data of the message to organize the data intoevents. In some embodiments, to organize the data into events, theindexing system 212 may determine a source type associated with eachmessage (e.g., by extracting a source type label from the metadatafields associated with the message, etc.) and refer to a source typeconfiguration corresponding to the identified source type. The sourcetype definition may include one or more properties that indicate to theindexing system 212 to automatically determine the boundaries within thereceived data that indicate the portions of machine data for events. Ingeneral, these properties may include regular expression-based rules ordelimiter rules where, for example, event boundaries may be indicated bypredefined characters or character strings. These predefined charactersmay include punctuation marks or other special characters including, forexample, carriage returns, tabs, spaces, line breaks, etc. If a sourcetype for the data is unknown to the indexing system 212, the indexingsystem 212 may infer a source type for the data by examining thestructure of the data. Then, the indexing system 212 can apply aninferred source type definition to the data to create the events.

At block 1108, the indexing system 212 determines a timestamp for eachevent Similar to the process for parsing machine data, an indexingsystem 212 may again refer to a source type definition associated withthe data to locate one or more properties that indicate instructions fordetermining a timestamp for each event. The properties may, for example,instruct the indexing system 212 to extract a time value from a portionof data for the event, to interpolate time values based on timestampsassociated with temporally proximate events, to create a time stampbased on a time the portion of machine data was received or generated,to use the timestamp of a previous event, or use any other rules fordetermining time stamps.

At block 1110, the indexing system 212 associates with each event one ormore metadata fields including a field containing the timestampdetermined for the event. In some embodiments, a timestamp may beincluded in the metadata fields. These metadata fields may include anynumber of “default fields” that are associated with all events, and mayalso include one more custom fields as defined by a user. Similar to themetadata fields associated with the data blocks at block 1104, thedefault metadata fields associated with each event may include a host,source, and source type field including or in addition to a fieldstoring the timestamp.

At block 1112, the indexing system 212 may optionally apply one or moretransformations to data included in the events created at block 1106.For example, such transformations can include removing a portion of anevent (e.g., a portion used to define event boundaries, extraneouscharacters from the event, other extraneous text, etc.), masking aportion of an event (e.g., masking a credit card number), removingredundant portions of an event, etc. The transformations applied toevents may, for example, be specified in one or more configuration filesand referenced by one or more source type definitions.

FIG. 11C illustrates an illustrative example of how machine data can bestored in a data store in accordance with various disclosed embodiments.In other embodiments, machine data can be stored in a flat file in acorresponding bucket with an associated index file, such as a timeseries index or “TSIDX.” As such, the depiction of machine data andassociated metadata as rows and columns in the table of FIG. 11C ismerely illustrative and is not intended to limit the data format inwhich the machine data and metadata is stored in various embodimentsdescribed herein. In one particular embodiment, machine data can bestored in a compressed or encrypted formatted. In such embodiments, themachine data can be stored with or be associated with data thatdescribes the compression or encryption scheme with which the machinedata is stored. The information about the compression or encryptionscheme can be used to decompress or decrypt the machine data, and anymetadata with which it is stored, at search time.

As mentioned above, certain metadata, e.g., host 1136, source 1137,source type 1138 and timestamps 1135 can be generated for each event,and associated with a corresponding portion of machine data 1139 whenstoring the event data in a data store, e.g., data store 208. Any of themetadata can be extracted from the corresponding machine data, orsupplied or defined by an entity, such as a user or computer system. Themetadata fields can become part of or stored with the event. Note thatwhile the time-stamp metadata field can be extracted from the raw dataof each event, the values for the other metadata fields may bedetermined by the indexing system 212 or indexing node 404 based oninformation it receives pertaining to the source of the data separatefrom the machine data.

While certain default or user-defined metadata fields can be extractedfrom the machine data for indexing purposes, all the machine data withinan event can be maintained in its original condition. As such, inembodiments in which the portion of machine data included in an event isunprocessed or otherwise unaltered, it is referred to herein as aportion of raw machine data. In other embodiments, the port of machinedata in an event can be processed or otherwise altered. As such, unlesscertain information needs to be removed for some reasons (e.g.extraneous information, confidential information), all the raw machinedata contained in an event can be preserved and saved in its originalform. Accordingly, the data store in which the event records are storedis sometimes referred to as a “raw record data store.” The raw recorddata store contains a record of the raw event data tagged with thevarious default fields.

In FIG. 11C, the first three rows of the table represent events 1131,1132, and 1133 and are related to a server access log that recordsrequests from multiple clients processed by a server, as indicated byentry of “access.log” in the source column 1137.

In the example shown in FIG. 11C, each of the events 1131-1133 isassociated with a discrete request made from a client device. The rawmachine data generated by the server and extracted from a server accesslog can include the IP address 1140 of the client, the user id 1141 ofthe person requesting the document, the time 1142 the server finishedprocessing the request, the request line 1143 from the client, thestatus code 1144 returned by the server to the client, the size of theobject 1145 returned to the client (in this case, the gif file requestedby the client) and the time spent 1146 to serve the request inmicroseconds. As seen in FIG. 11C, all the raw machine data retrievedfrom the server access log is retained and stored as part of thecorresponding events 1131-1133 in the data store.

Event 1134 is associated with an entry in a server error log, asindicated by “error.log” in the source column 1137 that records errorsthat the server encountered when processing a client request. Similar tothe events related to the server access log, all the raw machine data inthe error log file pertaining to event 1134 can be preserved and storedas part of the event 1134.

Saving minimally processed or unprocessed machine data in a data storeassociated with metadata fields in the manner similar to that shown inFIG. 11C is advantageous because it allows search of all the machinedata at search time instead of searching only previously specified andidentified fields or field-value pairs. As mentioned above, because datastructures used by various embodiments of the present disclosuremaintain the underlying raw machine data and use a late-binding schemafor searching the raw machines data, it enables a user to continueinvestigating and learn valuable insights about the raw data. In otherwords, the user is not compelled to know about all the fields ofinformation that will be needed at data ingestion time. As a user learnsmore about the data in the events, the user can continue to refine thelate-binding schema by defining new extraction rules, or modifying ordeleting existing extraction rules used by the system.

4.4.3. Indexing

At blocks 1114 and 1116, the indexing system 212 can optionally generatea keyword index to facilitate fast keyword searching for events. Tobuild a keyword index, at block 1114, the indexing system 212 identifiesa set of keywords in each event. At block 1116, the indexing system 212includes the identified keywords in an index, which associates eachstored keyword with reference pointers to events containing that keyword(or to locations within events where that keyword is located, otherlocation identifiers, etc.). When the data intake and query system 108subsequently receives a keyword-based query, the query system 214 canaccess the keyword index to quickly identify events containing thekeyword.

In some embodiments, the keyword index may include entries for fieldname-value pairs found in events, where a field name-value pair caninclude a pair of keywords connected by a symbol, such as an equals signor colon. This way, events containing these field name-value pairs canbe quickly located. In some embodiments, fields can automatically begenerated for some or all of the field names of the field name-valuepairs at the time of indexing. For example, if the string“dest=10.0.1.2” is found in an event, a field named “dest” may becreated for the event, and assigned a value of “10.0.1.2”.

At block 1118, the indexing system 212 stores the events with anassociated timestamp in a local data store 208 and/or common storage216. Timestamps enable a user to search for events based on a timerange. In some embodiments, the stored events are organized into“buckets,” where each bucket stores events associated with a specifictime range based on the timestamps associated with each event. Thisimproves time-based searching, as well as allows for events with recenttimestamps, which may have a higher likelihood of being accessed, to bestored in a faster memory to facilitate faster retrieval. For example,buckets containing the most recent events can be stored in flash memoryrather than on a hard disk. In some embodiments, each bucket may beassociated with an identifier, a time range, and a size constraint.

The indexing system 212 may be responsible for storing the eventscontained in various data stores 218 of common storage 216. Bydistributing events among the data stores in common storage 216, thequery system 214 can analyze events for a query in parallel. Forexample, using map-reduce techniques, each search node 506 can returnpartial responses for a subset of events to a search head that combinesthe results to produce an answer for the query. By storing events inbuckets for specific time ranges, the indexing system 212 may furtheroptimize the data retrieval process by enabling search nodes 506 tosearch buckets corresponding to time ranges that are relevant to aquery. In some embodiments, each bucket may be associated with anidentifier, a time range, and a size constraint. In certain embodiments,a bucket can correspond to a file system directory and the machine data,or events, of a bucket can be stored in one or more files of the filesystem directory. The file system directory can include additionalfiles, such as one or more inverted indexes, high performance indexes,permissions files, configuration files, etc.

In some embodiments, each indexing node 404 (e.g., the indexer 410 ordata store 412) of the indexing system 212 has a home directory and acold directory. The home directory stores hot buckets and warm buckets,and the cold directory stores cold buckets. A hot bucket is a bucketthat is capable of receiving and storing events. A warm bucket is abucket that can no longer receive events for storage but has not yetbeen moved to the cold directory. A cold bucket is a bucket that can nolonger receive events and may be a bucket that was previously stored inthe home directory. The home directory may be stored in faster memory,such as flash memory, as events may be actively written to the homedirectory, and the home directory may typically store events that aremore frequently searched and thus are accessed more frequently. The colddirectory may be stored in slower and/or larger memory, such as a harddisk, as events are no longer being written to the cold directory, andthe cold directory may typically store events that are not as frequentlysearched and thus are accessed less frequently. In some embodiments, anindexing node 404 may also have a quarantine bucket that contains eventshaving potentially inaccurate information, such as an incorrect timestamp associated with the event or a time stamp that appears to be anunreasonable time stamp for the corresponding event. The quarantinebucket may have events from any time range; as such, the quarantinebucket may always be searched at search time. Additionally, an indexingnode 404 may store old, archived data in a frozen bucket that is notcapable of being searched at search time. In some embodiments, a frozenbucket may be stored in slower and/or larger memory, such as a harddisk, and may be stored in offline and/or remote storage.

In some embodiments, an indexing node 404 may not include a colddirectory and/or cold or frozen buckets. For example, as warm bucketsand/or merged buckets are copied to common storage 216, they can bedeleted from the indexing node 404. In certain embodiments, one or moredata stores 218 of the common storage 216 can include a home directorythat includes warm buckets copied from the indexing nodes 404 and a colddirectory of cold or frozen buckets as described above.

Moreover, events and buckets can also be replicated across differentindexing nodes 404 and data stores 218 of the common storage 216.

FIG. 11B is a block diagram of an example data store 1101 that includesa directory for each index (or partition) that contains a portion ofdata stored in the data store 1101, and a sub-directory for one or morebuckets of the index. FIG. 11B further illustrates details of anembodiment of an inverted index 1107B and an event reference array 1115associated with inverted index 1107B.

The data store 1101 can correspond to a data store 218 that storesevents in common storage 216, a data store 412 associated with anindexing node 404, or a data store associated with a search node 506. Inthe illustrated embodiment, the data store 1101 includes a _maindirectory 1103A associated with a _main partition and a _test directory1103B associated with a _test partition. However, the data store 1101can include fewer or more directories. In some embodiments, multipleindexes can share a single directory or all indexes can share a commondirectory. Additionally, although illustrated as a single data store1101, it will be understood that the data store 1101 can be implementedas multiple data stores storing different portions of the informationshown in FIG. 11B. For example, a single index or partition can spanmultiple directories or multiple data stores, and can be indexed orsearched by multiple search nodes 506.

Furthermore, although not illustrated in FIG. 11B, it will be understoodthat, in some embodiments, the data store 1101 can include directoriesfor each tenant and sub-directories for each partition of each tenant,or vice versa. Accordingly, the directories 1103A and 1103B illustratedin FIG. 11B can, in certain embodiments, correspond to sub-directoriesof a tenant or include sub-directories for different tenants.

In the illustrated embodiment of FIG. 11B, two sub-directories 1105A,1105B of the _main directory 1103A and one sub-directory 1103C of the_test directory 1103B are shown. The sub-directories 1105A, 1105B, 1105Ccan correspond to buckets of the partitions associated with thedirectories 1103A, 1103B. For example, the sub-directories 1105A and1105B can correspond to buckets “B1” and “B2” of the partition “_main”and the sub-directory 1105C can correspond to bucket “B1” of thepartition “_test.” Accordingly, even though there are two buckets “B1,”as each “B1” bucket associated with a different partition (andcorresponding directory 1103), the system 108 can uniquely identifythem.

Although illustrated as buckets “B1” and “B2,” it will be understoodthat the buckets (and/or corresponding sub-directories 1105) can benamed in a variety of ways. In certain embodiments, the bucket (orsub-directory) names can include information about the bucket. Forexample, the bucket name can include the name of the partition withwhich the bucket is associated, a time range of the bucket, etc.

As described herein, each bucket can have one or more files associatedwith it, including, but not limited to one or more raw machine datafiles, bucket summary files, filter files, inverted indexes, highperformance indexes, permissions files, configuration files, etc. In theillustrated embodiment of FIG. 11B, the files associated with aparticular bucket can be stored in the sub-directory corresponding tothe particular bucket. Accordingly, the files stored in thesub-directory 1105A can correspond to or be associated with bucket “B1,”of partition “_main,” the files stored in the sub-directory 1105B cancorrespond to or be associated with bucket “B2” of partition “_main,”and the files stored in the sub-directory 1105C can correspond to or beassociated with bucket “B1” of partition “test.”

In the illustrated embodiment of FIG. 11B, each sub-directory1105A-1105C of the partition-specific directories 1103A and 1103Bincludes an inverted index 1107A, 1107B, 1107C, respectively(generically referred to as inverted index(es) 1107). The invertedindexes 1107 can be keyword indexes or field-value pair indexesdescribed herein and can include less or more information than depictedin FIG. 11B.

In some embodiments, the inverted indexes 1107 can correspond todistinct time-series buckets stored in common storage 216, a search node506, or an indexing node 404 and that contains events corresponding tothe relevant partition (e.g., _main partition, _test partition). Assuch, each inverted index 1107 can correspond to a particular range oftime for a partition. In the illustrated embodiment of FIG. 11B, eachinverted index 1107 corresponds to the bucket associated with thesub-directory 1103 in which the inverted index 1107 is located. In someembodiments, an inverted index 1107 can correspond to multipletime-series buckets (e.g., include information related to multiplebuckets) or inverted indexes 1107 can correspond to a single time-seriesbucket.

In the illustrated embodiment of FIG. 11B, each sub-directory 1105includes additional files. In the illustrated embodiment, the additionalfiles include raw data files 1108A-1108C, high performance indexes1109A-1109C, and filter files 1110A-110C. However, it will be understoodthat each bucket can be associated with fewer or more files and eachsub-directory can store fewer or more files.

Each inverted index 1107 can include one or more entries, such askeyword (or token) entries or field-value pair entries. Furthermore, incertain embodiments, the inverted indexes 1107 can include additionalinformation, such as a time range 1123 associated with the invertedindex or a partition identifier 1125 identifying the partitionassociated with the inverted index 1107. It will be understood that eachinverted index 1107 can include less or more information than depicted.

Token entries, such as token entries 1111 illustrated in inverted index1107B, can include a token 1111A (e.g., “error,” “itemID,” etc.) andevent references 1111B indicative of events that include the token. Forexample, for the token “error,” the corresponding token entry includesthe token “error” and an event reference, or unique identifier, for eachevent stored in the corresponding time-series bucket that includes thetoken “error.” In the illustrated embodiment of FIG. 11B, the errortoken entry includes the identifiers 3, 5, 6, 8, 11, and 12corresponding to events located in the time-series bucket associatedwith the inverted index 1107B that is stored in common storage 216, asearch node 506, or an indexing node 404 and is associated with thepartition “_main,” which in turn is associated with the directory 1103A.

In some cases, some token entries can be default entries, automaticallydetermined entries, or user specified entries. In some embodiments, theindexing system 212 can identify each word or string in an event as adistinct token and generate a token entry for the identified word orstring. In some cases, the indexing system 212 can identify thebeginning and ending of tokens based on punctuation, spaces, asdescribed in greater detail herein. In certain cases, the indexingsystem 212 can rely on user input or a configuration file to identifytokens for token entries 1111, etc. It will be understood that anycombination of token entries can be included as a default, automaticallydetermined, or included based on user-specified criteria.

Similarly, field-value pair entries, such as field-value pair entries1113 shown in inverted index 1107B, can include a field-value pair 1113Aand event references 1113B indicative of events that include a fieldvalue that corresponds to the field-value pair. For example, for afield-value pair sourcetype::sendmail, a field-value pair entry caninclude the field-value pair sourcetype::sendmail and a uniqueidentifier, or event reference, for each event stored in thecorresponding time-series bucket that includes a sendmail sourcetype.

In some cases, the field-value pair entries 1113 can be default entries,automatically determined entries, or user specified entries. As anon-limiting example, the field-value pair entries for the fields host,source, and sourcetype can be included in the inverted indexes 1107 as adefault. As such, all of the inverted indexes 1107 can includefield-value pair entries for the fields host, source, sourcetype. As yetanother non-limiting example, the field-value pair entries for theIP_address field can be user specified and may only appear in theinverted index 1107B based on user-specified criteria. As anothernon-limiting example, as the indexing system 212 indexes the events, itcan automatically identify field-value pairs and create field-value pairentries. For example, based on the indexing system's 212 review ofevents, it can identify IP_address as a field in each event and add theIP_address field-value pair entries to the inverted index 1107B. It willbe understood that any combination of field-value pair entries can beincluded as a default, automatically determined, or included based onuser-specified criteria.

With reference to the event reference array 1115, each unique identifier1117, or event reference, can correspond to a unique event located inthe time series bucket. However, the same event reference can be locatedin multiple entries of an inverted index. For example if an event has asourcetype “splunkd,” host “www1” and token “warning,” then the uniqueidentifier for the event will appear in the field-value pair entriessourcetype::splunkd and host::www1, as well as the token entry“warning.” With reference to the illustrated embodiment of FIG. 11B andthe event that corresponds to the event reference 3, the event reference3 is found in the field-value pair entries 1113 host::hostA,source::sourceB, sourcetype::sourcetypeA, and IP_address::91.205.189.15indicating that the event corresponding to the event references is fromhostA, sourceB, of sourcetypeA, and includes 91.205.189.15 in the eventdata.

For some fields, the unique identifier is located in only onefield-value pair entry for a particular field. For example, the invertedindex may include four sourcetype field-value pair entries correspondingto four different sourcetypes of the events stored in a bucket (e.g.,sourcetypes: sendmail, splunkd, web_access, and web_service). Withinthose four sourcetype field-value pair entries, an identifier for aparticular event may appear in only one of the field-value pair entries.With continued reference to the example illustrated embodiment of FIG.11B, since the event reference 7 appears in the field-value pair entrysourcetype::sourcetypeA, then it does not appear in the otherfield-value pair entries for the sourcetype field, includingsourcetype::sourcetypeB, sourcetype::sourcetypeC, andsourcetype::sourcetypeD.

The event references 1117 can be used to locate the events in thecorresponding bucket. For example, the inverted index can include, or beassociated with, an event reference array 1115. The event referencearray 1115 can include an array entry 1117 for each event reference inthe inverted index 1107B. Each array entry 1117 can include locationinformation 1119 of the event corresponding to the unique identifier(non-limiting example: seek address of the event), a timestamp 1121associated with the event, or additional information regarding the eventassociated with the event reference, etc.

For each token entry 1111 or field-value pair entry 1113, the eventreference 1101B or unique identifiers can be listed in chronologicalorder or the value of the event reference can be assigned based onchronological data, such as a timestamp associated with the eventreferenced by the event reference. For example, the event reference 1 inthe illustrated embodiment of FIG. 11B can correspond to thefirst-in-time event for the bucket, and the event reference 12 cancorrespond to the last-in-time event for the bucket. However, the eventreferences can be listed in any order, such as reverse chronologicalorder, ascending order, descending order, or some other order, etc.Further, the entries can be sorted. For example, the entries can besorted alphabetically (collectively or within a particular group), byentry origin (e.g., default, automatically generated, user-specified,etc.), by entry type (e.g., field-value pair entry, token entry, etc.),or chronologically by when added to the inverted index, etc. In theillustrated embodiment of FIG. 11B, the entries are sorted first byentry type and then alphabetically.

As a non-limiting example of how the inverted indexes 1107 can be usedduring a data categorization request command, the query system 214 canreceive filter criteria indicating data that is to be categorized andcategorization criteria indicating how the data is to be categorized.Example filter criteria can include, but is not limited to, indexes (orpartitions), hosts, sources, sourcetypes, time ranges, field identifier,tenant and/or user identifiers, keywords, etc.

Using the filter criteria, the query system 214 identifies relevantinverted indexes to be searched. For example, if the filter criteriaincludes a set of partitions (also referred to as indexes), the querysystem 214 can identify the inverted indexes stored in the directorycorresponding to the particular partition as relevant inverted indexes.Other means can be used to identify inverted indexes associated with apartition of interest. For example, in some embodiments, the querysystem 214 can review an entry in the inverted indexes, such as apartition-value pair entry 1113 to determine if a particular invertedindex is relevant. If the filter criteria does not identify anypartition, then the query system 214 can identify all inverted indexesmanaged by the query system 214 as relevant inverted indexes.

Similarly, if the filter criteria includes a time range, the querysystem 214 can identify inverted indexes corresponding to buckets thatsatisfy at least a portion of the time range as relevant invertedindexes. For example, if the time range is last hour then the querysystem 214 can identify all inverted indexes that correspond to bucketsstoring events associated with timestamps within the last hour asrelevant inverted indexes.

When used in combination, an index filter criterion specifying one ormore partitions and a time range filter criterion specifying aparticular time range can be used to identify a subset of invertedindexes within a particular directory (or otherwise associated with aparticular partition) as relevant inverted indexes. As such, the querysystem 214 can focus the processing to only a subset of the total numberof inverted indexes in the data intake and query system 108.

Once the relevant inverted indexes are identified, the query system 214can review them using any additional filter criteria to identify eventsthat satisfy the filter criteria. In some cases, using the knownlocation of the directory in which the relevant inverted indexes arelocated, the query system 214 can determine that any events identifiedusing the relevant inverted indexes satisfy an index filter criterion.For example, if the filter criteria includes a partition main, then thequery system 214 can determine that any events identified using invertedindexes within the partition main directory (or otherwise associatedwith the partition main) satisfy the index filter criterion.

Furthermore, based on the time range associated with each invertedindex, the query system 214 can determine that any events identifiedusing a particular inverted index satisfies a time range filtercriterion. For example, if a time range filter criterion is for the lasthour and a particular inverted index corresponds to events within a timerange of 50 minutes ago to 35 minutes ago, the query system 214 candetermine that any events identified using the particular inverted indexsatisfy the time range filter criterion. Conversely, if the particularinverted index corresponds to events within a time range of 59 minutesago to 62 minutes ago, the query system 214 can determine that someevents identified using the particular inverted index may not satisfythe time range filter criterion.

Using the inverted indexes, the query system 214 can identify eventreferences (and therefore events) that satisfy the filter criteria. Forexample, if the token “error” is a filter criterion, the query system214 can track all event references within the token entry “error.”Similarly, the query system 214 can identify other event referenceslocated in other token entries or field-value pair entries that matchthe filter criteria. The system can identify event references located inall of the entries identified by the filter criteria. For example, ifthe filter criteria include the token “error” and field-value pairsourcetype::web_ui, the query system 214 can track the event referencesfound in both the token entry “error” and the field-value pair entrysourcetype::web_ui. As mentioned previously, in some cases, such as whenmultiple values are identified for a particular filter criterion (e.g.,multiple sources for a source filter criterion), the system can identifyevent references located in at least one of the entries corresponding tothe multiple values and in all other entries identified by the filtercriteria. The query system 214 can determine that the events associatedwith the identified event references satisfy the filter criteria.

In some cases, the query system 214 can further consult a timestampassociated with the event reference to determine whether an eventsatisfies the filter criteria. For example, if an inverted indexcorresponds to a time range that is partially outside of a time rangefilter criterion, then the query system 214 can consult a timestampassociated with the event reference to determine whether thecorresponding event satisfies the time range criterion. In someembodiments, to identify events that satisfy a time range, the querysystem 214 can review an array, such as the event reference array 1115that identifies the time associated with the events. Furthermore, asmentioned above using the known location of the directory in which therelevant inverted indexes are located (or other partition identifier),the query system 214 can determine that any events identified using therelevant inverted indexes satisfy the index filter criterion.

In some cases, based on the filter criteria, the query system 214reviews an extraction rule. In certain embodiments, if the filtercriteria includes a field name that does not correspond to a field-valuepair entry in an inverted index, the query system 214 can review anextraction rule, which may be located in a configuration file, toidentify a field that corresponds to a field-value pair entry in theinverted index.

For example, the filter criteria includes a field name “sessionID” andthe query system 214 determines that at least one relevant invertedindex does not include a field-value pair entry corresponding to thefield name sessionID, the query system 214 can review an extraction rulethat identifies how the sessionID field is to be extracted from aparticular host, source, or sourcetype (implicitly identifying theparticular host, source, or sourcetype that includes a sessionID field).The query system 214 can replace the field name “sessionID” in thefilter criteria with the identified host, source, or sourcetype. In somecases, the field name “sessionID” may be associated with multipleshosts, sources, or sourcetypes, in which case, all identified hosts,sources, and sourcetypes can be added as filter criteria. In some cases,the identified host, source, or sourcetype can replace or be appended toa filter criterion, or be excluded. For example, if the filter criteriaincludes a criterion for source S1 and the “sessionID” field is found insource S2, the source S2 can replace S1 in the filter criteria, beappended such that the filter criteria includes source S1 and source S2,or be excluded based on the presence of the filter criterion source S1.If the identified host, source, or sourcetype is included in the filtercriteria, the query system 214 can then identify a field-value pairentry in the inverted index that includes a field value corresponding tothe identity of the particular host, source, or sourcetype identifiedusing the extraction rule.

Once the events that satisfy the filter criteria are identified, thequery system 214 can categorize the results based on the categorizationcriteria. The categorization criteria can include categories forgrouping the results, such as any combination of partition, source,sourcetype, or host, or other categories or fields as desired.

The query system 214 can use the categorization criteria to identifycategorization criteria-value pairs or categorization criteria values bywhich to categorize or group the results. The categorizationcriteria-value pairs can correspond to one or more field-value pairentries stored in a relevant inverted index, one or more partition-valuepairs based on a directory in which the inverted index is located or anentry in the inverted index (or other means by which an inverted indexcan be associated with a partition), or other criteria-value pair thatidentifies a general category and a particular value for that category.The categorization criteria values can correspond to the value portionof the categorization criteria-value pair.

As mentioned, in some cases, the categorization criteria-value pairs cancorrespond to one or more field-value pair entries stored in therelevant inverted indexes. For example, the categorizationcriteria-value pairs can correspond to field-value pair entries of host,source, and sourcetype (or other field-value pair entry as desired). Forinstance, if there are ten different hosts, four different sources, andfive different sourcetypes for an inverted index, then the invertedindex can include ten host field-value pair entries, four sourcefield-value pair entries, and five sourcetype field-value pair entries.The query system 214 can use the nineteen distinct field-value pairentries as categorization criteria-value pairs to group the results.

Specifically, the query system 214 can identify the location of theevent references associated with the events that satisfy the filtercriteria within the field-value pairs, and group the event referencesbased on their location. As such, the query system 214 can identify theparticular field value associated with the event corresponding to theevent reference. For example, if the categorization criteria includehost and sourcetype, the host field-value pair entries and sourcetypefield-value pair entries can be used as categorization criteria-valuepairs to identify the specific host and sourcetype associated with theevents that satisfy the filter criteria.

In addition, as mentioned, categorization criteria-value pairs cancorrespond to data other than the field-value pair entries in therelevant inverted indexes. For example, if partition or index is used asa categorization criterion, the inverted indexes may not includepartition field-value pair entries. Rather, the query system 214 canidentify the categorization criteria-value pair associated with thepartition based on the directory in which an inverted index is located,information in the inverted index, or other information that associatesthe inverted index with the partition, etc. As such a variety of methodscan be used to identify the categorization criteria-value pairs from thecategorization criteria.

Accordingly based on the categorization criteria (and categorizationcriteria-value pairs), the query system 214 can generate groupings basedon the events that satisfy the filter criteria. As a non-limitingexample, if the categorization criteria includes a partition andsourcetype, then the groupings can correspond to events that areassociated with each unique combination of partition and sourcetype. Forinstance, if there are three different partitions and two differentsourcetypes associated with the identified events, then the sixdifferent groups can be formed, each with a unique partitionvalue-sourcetype value combination. Similarly, if the categorizationcriteria includes partition, sourcetype, and host and there are twodifferent partitions, three sourcetypes, and five hosts associated withthe identified events, then the query system 214 can generate up tothirty groups for the results that satisfy the filter criteria. Eachgroup can be associated with a unique combination of categorizationcriteria-value pairs (e.g., unique combinations of partition valuesourcetype value, and host value).

In addition, the query system 214 can count the number of eventsassociated with each group based on the number of events that meet theunique combination of categorization criteria for a particular group (ormatch the categorization criteria-value pairs for the particular group).With continued reference to the example above, the query system 214 cancount the number of events that meet the unique combination ofpartition, sourcetype, and host for a particular group.

The query system 214, such as the search head 504 can aggregate thegroupings from the buckets, or search nodes 506, and provide thegroupings for display. In some cases, the groups are displayed based onat least one of the host, source, sourcetype, or partition associatedwith the groupings. In some embodiments, the query system 214 canfurther display the groups based on display criteria, such as a displayorder or a sort order as described in greater detail above.

As a non-limiting example and with reference to FIG. 11B, consider arequest received by the query system 214 that includes the followingfilter criteria: keyword=error, partition=main, time range=3/1/1716:22.00.000-16:28.00.000, sourcetype=sourcetypeC, host=hostB, and thefollowing categorization criteria: source.

Based on the above criteria, a search node 506 of the query system 214that is associated with the data store 1101 identifies _main directory1103A and can ignore _test directory 1103B and any otherpartition-specific directories. The search node 506 determines thatinverted index 1107B is a relevant index based on its location withinthe _main directory 1103A and the time range associated with it. Forsake of simplicity in this example, the search node 506 determines thatno other inverted indexes in the _main directory 1103A, such as invertedindex 1107A satisfy the time range criterion.

Having identified the relevant inverted index 1107B, the search node 506reviews the token entries 1111 and the field-value pair entries 1113 toidentify event references, or events that satisfy all of the filtercriteria.

With respect to the token entries 1111, the search node 506 can reviewthe error token entry and identify event references 3, 5, 6, 8, 11, 12,indicating that the term “error” is found in the corresponding events.Similarly, the search node 506 can identify event references 4, 5, 6, 8,9, 10, 11 in the field-value pair entry sourcetype::sourcetypeC andevent references 2, 5, 6, 8, 10, 11 in the field-value pair entryhost::hostB. As the filter criteria did not include a source or anIP_address field-value pair, the search node 506 can ignore thosefield-value pair entries.

In addition to identifying event references found in at least one tokenentry or field-value pair entry (e.g., event references 3, 4, 5, 6, 8,9, 10, 11, 12), the search node 506 can identify events (andcorresponding event references) that satisfy the time range criterionusing the event reference array 1115 (e.g., event references 2, 3, 4, 5,6, 7, 8, 9, 10). Using the information obtained from the inverted index1107B (including the event reference array 1115), the search node 506can identify the event references that satisfy all of the filtercriteria (e.g., event references 5, 6, 8).

Having identified the events (and event references) that satisfy all ofthe filter criteria, the search node 506 can group the event referencesusing the received categorization criteria (source). In doing so, thesearch node 506 can determine that event references 5 and 6 are locatedin the field-value pair entry source::sourceD (or have matchingcategorization criteria-value pairs) and event reference 8 is located inthe field-value pair entry source::sourceC. Accordingly, the search node506 can generate a sourceC group having a count of one corresponding toreference 8 and a sourceD group having a count of two corresponding toreferences 5 and 6. This information can be communicated to the searchhead 504. In turn the search head 504 can aggregate the results from thevarious search nodes 506 and display the groupings. As mentioned above,in some embodiments, the groupings can be displayed based at least inpart on the categorization criteria, including at least one of host,source, sourcetype, or partition.

It will be understood that a change to any of the filter criteria orcategorization criteria can result in different groupings. As a onenon-limiting example, consider a request received by a search node 506that includes the following filter criteria: partition=main, timerange=3/1/17 3/1/17 16:21:20.000-16:28:17.000, and the followingcategorization criteria: host, source, sourcetype can result in thesearch node 506 identifying event references 1-12 as satisfying thefilter criteria. The search node 506 can generate up to 24 groupingscorresponding to the 24 different combinations of the categorizationcriteria-value pairs, including host (hostA, hostB), source (sourceA,sourceB, sourceC, sourceD), and sourcetype (sourcetypeA, sourcetypeB,sourcetypeC). However, as there are only twelve events identifiers inthe illustrated embodiment and some fall into the same grouping, thesearch node 506 generates eight groups and counts as follows:

Group 1 (hostA, sourceA, sourcetypeA): 1 (event reference 7)

Group 2 (hostA, sourceA, sourcetypeB): 2 (event references 1, 12)

Group 3 (hostA, sourceA, sourcetypeC): 1 (event reference 4)

Group 4 (hostA, sourceB, sourcetypeA): 1 (event reference 3)

Group 5 (hostA, sourceB, sourcetypeC): 1 (event reference 9)

Group 6 (hostB, sourceC, sourcetypeA): 1 (event reference 2)

Group 7 (hostB, sourceC, sourcetypeC): 2 (event references 8, 11)

Group 8 (hostB, sourceD, sourcetypeC): 3 (event references 5, 6, 10)

As noted, each group has a unique combination of categorizationcriteria-value pairs or categorization criteria values. The search node506 communicates the groups to the search head 504 for aggregation withresults received from other search nodes 506. In communicating thegroups to the search head 504, the search node 506 can include thecategorization criteria-value pairs for each group and the count. Insome embodiments, the search node 506 can include more or lessinformation. For example, the search node 506 can include the eventreferences associated with each group and other identifying information,such as the search node 506 or inverted index used to identify thegroups.

As another non-limiting example, consider a request received by ansearch node 506 that includes the following filter criteria:partition=_main, time range=3/1/17 3/1/17 16:21:20.000-16:28:17.000,source=sourceA, sourceD, and keyword=itemID and the followingcategorization criteria: host, source, sourcetype can result in thesearch node identifying event references 4, 7, and 10 as satisfying thefilter criteria, and generate the following groups:

Group 1 (hostA, sourceA, sourcetypeC): 1 (event reference 4)

Group 2 (hostA, sourceA, sourcetypeA): 1 (event reference 7)

Group 3 (hostB, sourceD, sourcetypeC): 1 (event references 10)

The search node 506 communicates the groups to the search head 504 foraggregation with results received from other search nodes 506. As willbe understand there are myriad ways for filtering and categorizing theevents and event references. For example, the search node 506 can reviewmultiple inverted indexes associated with a partition or review theinverted indexes of multiple partitions, and categorize the data usingany one or any combination of partition, host, source, sourcetype, orother category, as desired.

Further, if a user interacts with a particular group, the search node506 can provide additional information regarding the group. For example,the search node 506 can perform a targeted search or sampling of theevents that satisfy the filter criteria and the categorization criteriafor the selected group, also referred to as the filter criteriacorresponding to the group or filter criteria associated with the group.

In some cases, to provide the additional information, the search node506 relies on the inverted index. For example, the search node 506 canidentify the event references associated with the events that satisfythe filter criteria and the categorization criteria for the selectedgroup and then use the event reference array 1115 to access some or allof the identified events. In some cases, the categorization criteriavalues or categorization criteria-value pairs associated with the groupbecome part of the filter criteria for the review.

With reference to FIG. 11B for instance, suppose a group is displayedwith a count of six corresponding to event references 4, 5, 6, 8, 10, 11(i.e., event references 4, 5, 6, 8, 10, 11 satisfy the filter criteriaand are associated with matching categorization criteria values orcategorization criteria-value pairs) and a user interacts with the group(e.g., selecting the group, clicking on the group, etc.). In response,the search head 504 communicates with the search node 506 to provideadditional information regarding the group.

In some embodiments, the search node 506 identifies the event referencesassociated with the group using the filter criteria and thecategorization criteria for the group (e.g., categorization criteriavalues or categorization criteria-value pairs unique to the group).Together, the filter criteria and the categorization criteria for thegroup can be referred to as the filter criteria associated with thegroup. Using the filter criteria associated with the group, the searchnode 506 identifies event references 4, 5, 6, 8, 10, 11.

Based on a sampling criteria, discussed in greater detail above, thesearch node 506 can determine that it will analyze a sample of theevents associated with the event references 4, 5, 6, 8, 10, 11. Forexample, the sample can include analyzing event data associated with theevent references 5, 8, 10. In some embodiments, the search node 506 canuse the event reference array 1115 to access the event data associatedwith the event references 5, 8, 10. Once accessed, the search node 506can compile the relevant information and provide it to the search head504 for aggregation with results from other search nodes. By identifyingevents and sampling event data using the inverted indexes, the searchnode can reduce the amount of actual data this is analyzed and thenumber of events that are accessed in order to generate the summary ofthe group and provide a response in less time.

4.5. Query Processing Flow

FIG. 12A is a flow diagram illustrating an embodiment of a routineimplemented by the query system 214 for executing a query. At block1202, a search head 504 receives a search query. At block 1204, thesearch head 504 analyzes the search query to determine what portion(s)of the query to delegate to search nodes 506 and what portions of thequery to execute locally by the search head 504. At block 1206, thesearch head distributes the determined portions of the query to theappropriate search nodes 506. In some embodiments, a search head clustermay take the place of an independent search head 504 where each searchhead 504 in the search head cluster coordinates with peer search heads504 in the search head cluster to schedule jobs, replicate searchresults, update configurations, fulfill search requests, etc. In someembodiments, the search head 504 (or each search head) consults with aresource catalog 510 that provides the search head with a list of searchnodes 506 to which the search head can distribute the determinedportions of the query. A search head 504 may communicate with theresource catalog 510 to discover the addresses of active search nodes506.

At block 1208, the search nodes 506 to which the query was distributed,search data stores associated with them for events that are responsiveto the query. To determine which events are responsive to the query, thesearch node 506 searches for events that match the criteria specified inthe query. These criteria can include matching keywords or specificvalues for certain fields. The searching operations at block 1208 mayuse the late-binding schema to extract values for specified fields fromevents at the time the query is processed. In some embodiments, one ormore rules for extracting field values may be specified as part of asource type definition in a configuration file. The search nodes 506 maythen either send the relevant events back to the search head 504, or usethe events to determine a partial result, and send the partial resultback to the search head 504.

At block 1210, the search head 504 combines the partial results and/orevents received from the search nodes 506 to produce a final result forthe query. In some examples, the results of the query are indicative ofperformance or security of the IT environment and may help improve theperformance of components in the IT environment. This final result maycomprise different types of data depending on what the query requested.For example, the results can include a listing of matching eventsreturned by the query, or some type of visualization of the data fromthe returned events. In another example, the final result can includeone or more calculated values derived from the matching events.

The results generated by the system 108 can be returned to a clientusing different techniques. For example, one technique streams resultsor relevant events back to a client in real-time as they are identified.Another technique waits to report the results to the client until acomplete set of results (which may include a set of relevant events or aresult based on relevant events) is ready to return to the client. Yetanother technique streams interim results or relevant events back to theclient in real-time until a complete set of results is ready, and thenreturns the complete set of results to the client. In another technique,certain results are stored as “search jobs” and the client may retrievethe results by referring the search jobs.

The search head 504 can also perform various operations to make thesearch more efficient. For example, before the search head 504 beginsexecution of a query, the search head 504 can determine a time range forthe query and a set of common keywords that all matching events include.The search head 504 may then use these parameters to query the searchnodes 506 to obtain a superset of the eventual results. Then, during afiltering stage, the search head 504 can perform field-extractionoperations on the superset to produce a reduced set of search results.This speeds up queries, which may be particularly helpful for queriesthat are performed on a periodic basis.

4.6. Pipelined Search Language

Various embodiments of the present disclosure can be implemented using,or in conjunction with, a pipelined command language. A pipelinedcommand language is a language in which a set of inputs or data isoperated on by a first command in a sequence of commands, and thensubsequent commands in the order they are arranged in the sequence. Suchcommands can include any type of functionality for operating on data,such as retrieving, searching, filtering, aggregating, processing,transmitting, and the like. As described herein, a query can thus beformulated in a pipelined command language and include any number ofordered or unordered commands for operating on data.

Splunk Processing Language (SPL) is an example of a pipelined commandlanguage in which a set of inputs or data is operated on by any numberof commands in a particular sequence. A sequence of commands, or commandsequence, can be formulated such that the order in which the commandsare arranged defines the order in which the commands are applied to aset of data or the results of an earlier executed command. For example,a first command in a command sequence can operate to search or filterfor specific data in particular set of data. The results of the firstcommand can then be passed to another command listed later in thecommand sequence for further processing.

In various embodiments, a query can be formulated as a command sequencedefined in a command line of a search UI. In some embodiments, a querycan be formulated as a sequence of SPL commands. Some or all of the SPLcommands in the sequence of SPL commands can be separated from oneanother by a pipe symbol “|”. In such embodiments, a set of data, suchas a set of events, can be operated on by a first SPL command in thesequence, and then a subsequent SPL command following a pipe symbol “|”after the first SPL command operates on the results produced by thefirst SPL command or other set of data, and so on for any additional SPLcommands in the sequence. As such, a query formulated using SPLcomprises a series of consecutive commands that are delimited by pipe“|” characters. The pipe character indicates to the system that theoutput or result of one command (to the left of the pipe) should be usedas the input for one of the subsequent commands (to the right of thepipe). This enables formulation of queries defined by a pipeline ofsequenced commands that refines or enhances the data at each step alongthe pipeline until the desired results are attained. Accordingly,various embodiments described herein can be implemented with SplunkProcessing Language (SPL) used in conjunction with the SPLUNK®ENTERPRISE system.

While a query can be formulated in many ways, a query can start with asearch command and one or more corresponding search terms at thebeginning of the pipeline. Such search terms can include any combinationof keywords, phrases, times, dates, Boolean expressions, fieldname-fieldvalue pairs, etc. that specify which results should be obtained from anindex. The results can then be passed as inputs into subsequent commandsin a sequence of commands by using, for example, a pipe character. Thesubsequent commands in a sequence can include directives for additionalprocessing of the results once it has been obtained from one or moreindexes. For example, commands may be used to filter unwantedinformation out of the results, extract more information, evaluate fieldvalues, calculate statistics, reorder the results, create an alert,create summary of the results, or perform some type of aggregationfunction. In some embodiments, the summary can include a graph, chart,metric, or other visualization of the data. An aggregation function caninclude analysis or calculations to return an aggregate value, such asan average value, a sum, a maximum value, a root mean square,statistical values, and the like.

Due to its flexible nature, use of a pipelined command language invarious embodiments is advantageous because it can perform “filtering”as well as “processing” functions. In other words, a single query caninclude a search command and search term expressions, as well asdata-analysis expressions. For example, a command at the beginning of aquery can perform a “filtering” step by retrieving a set of data basedon a condition (e.g., records associated with server response times ofless than 1 microsecond). The results of the filtering step can then bepassed to a subsequent command in the pipeline that performs a“processing” step (e.g. calculation of an aggregate value related to thefiltered events such as the average response time of servers withresponse times of less than 1 microsecond). Furthermore, the searchcommand can allow events to be filtered by keyword as well as fieldvalue criteria. For example, a search command can filter out all eventscontaining the word “warning” or filter out all events where a fieldvalue associated with a field “clientip” is “10.0.1.2.”

The results obtained or generated in response to a command in a querycan be considered a set of results data. The set of results data can bepassed from one command to another in any data format. In oneembodiment, the set of result data can be in the form of a dynamicallycreated table. Each command in a particular query can redefine the shapeof the table. In some implementations, an event retrieved from an indexin response to a query can be considered a row with a column for eachfield value. Columns contain basic information about the data and alsomay contain data that has been dynamically extracted at search time.

FIG. 12B provides a visual representation of the manner in which apipelined command language or query operates in accordance with thedisclosed embodiments. The query 1230 can be inputted by the user into asearch. The query comprises a search, the results of which are piped totwo commands (namely, command 1 and command 2) that follow the searchstep.

Disk 1222 represents the event data in the raw record data store.

When a user query is processed, a search step will precede other queriesin the pipeline in order to generate a set of events at block 1240. Forexample, the query can comprise search terms “sourcetype=syslog ERROR”at the front of the pipeline as shown in FIG. 12B. Intermediate resultstable 1224 shows fewer rows because it represents the subset of eventsretrieved from the index that matched the search terms“sourcetype=syslog ERROR” from search command 1230. By way of furtherexample, instead of a search step, the set of events at the head of thepipeline may be generating by a call to a pre-existing inverted index(as will be explained later).

At block 1242, the set of events generated in the first part of thequery may be piped to a query that searches the set of events forfield-value pairs or for keywords. For example, the second intermediateresults table 1226 shows fewer columns, representing the result of thetop command, “top user” which summarizes the events into a list of thetop 10 users and displays the user, count, and percentage.

Finally, at block 1244, the results of the prior stage can be pipelinedto another stage where further filtering or processing of the data canbe performed, e.g., preparing the data for display purposes, filteringthe data based on a condition, performing a mathematical calculationwith the data, etc. As shown in FIG. 12B, the “fields—percent” part ofcommand 1230 removes the column that shows the percentage, thereby,leaving a final results table 1228 without a percentage column. Indifferent embodiments, other query languages, such as the StructuredQuery Language (“SQL”), can be used to create a query.

4.7. Field Extraction

The query system 214 allows users to search and visualize eventsgenerated from machine data received from heterogeneous data sources.The query system 214 also allows users to search and visualize eventsgenerated from machine data received from heterogeneous data sources.The query system 214 includes various components for processing a query,such as, but not limited to a query system manager 502, one or moresearch heads 504 having one or more search masters 512 and searchmanagers 514, and one or more search nodes 506. A query language may beused to create a query, such as any suitable pipelined query language.For example, Splunk Processing Language (SPL) can be utilized to make aquery. SPL is a pipelined search language in which a set of inputs isoperated on by a first command in a command line, and then a subsequentcommand following the pipe symbol “|” operates on the results producedby the first command, and so on for additional commands Other querylanguages, such as the Structured Query Language (“SQL”), can be used tocreate a query.

In response to receiving the search query, a search head 504 (e.g., asearch master 512 or search manager 514) can use extraction rules toextract values for fields in the events being searched. The search head504 can obtain extraction rules that specify how to extract a value forfields from an event. Extraction rules can comprise regex rules thatspecify how to extract values for the fields corresponding to theextraction rules. In addition to specifying how to extract field values,the extraction rules may also include instructions for deriving a fieldvalue by performing a function on a character string or value retrievedby the extraction rule. For example, an extraction rule may truncate acharacter string or convert the character string into a different dataformat. In some cases, the query itself can specify one or moreextraction rules.

The search head 504 can apply the extraction rules to events that itreceives from search nodes 506. The search nodes 506 may apply theextraction rules to events in an associated data store or common storage216. Extraction rules can be applied to all the events in a data storeor common storage 216 or to a subset of the events that have beenfiltered based on some criteria (e.g., event time stamp values, etc.).Extraction rules can be used to extract one or more values for a fieldfrom events by parsing the portions of machine data in the events andexamining the data for one or more patterns of characters, numbers,delimiters, etc., that indicate where the field begins and, optionally,ends.

FIG. 13A is a diagram of an example scenario where a common customeridentifier is found among log data received from three disparate datasources, in accordance with example embodiments. In this example, a usersubmits an order for merchandise using a vendor's shopping applicationprogram 1301 running on the user's system. In this example, the orderwas not delivered to the vendor's server due to a resource exception atthe destination server that is detected by the middleware code 1302. Theuser then sends a message to the customer support server 1303 tocomplain about the order failing to complete. The three systems 1301,1302, and 1303 are disparate systems that do not have a common loggingformat. The order application 1301 sends log data 1304 to the dataintake and query system 108 in one format, the middleware code 1302sends error log data 1305 in a second format, and the support server1303 sends log data 1306 in a third format.

Using the log data received at the data intake and query system 108 fromthe three systems, the vendor can uniquely obtain an insight into useractivity, user experience, and system behavior. The query system 214allows the vendor's administrator to search the log data from the threesystems, thereby obtaining correlated information, such as the ordernumber and corresponding customer ID number of the person placing theorder. The system also allows the administrator to see a visualizationof related events via a user interface. The administrator ca query thequery system 214 for customer ID field value matches across the log datafrom the three systems that are stored in common storage 216. Thecustomer ID field value exists in the data gathered from the threesystems, but the customer ID field value may be located in differentareas of the data given differences in the architecture of the systems.There is a semantic relationship between the customer ID field valuesgenerated by the three systems. The query system 214 requests eventsfrom the one or more data stores 218 to gather relevant events from thethree systems. The search head 504 then applies extraction rules to theevents in order to extract field values that it can correlate. Thesearch head 504 may apply a different extraction rule to each set ofevents from each system when the event format differs among systems. Inthis example, the user interface can display to the administrator theevents corresponding to the common customer ID field values 1307, 1308,and 1309, thereby providing the administrator with insight into acustomer's experience.

Note that query results can be returned to a client, a search head 504,or any other system component for further processing. In general, queryresults may include a set of one or more events, a set of one or morevalues obtained from the events, a subset of the values, statisticscalculated based on the values, a report containing the values, avisualization (e.g., a graph or chart) generated from the values, andthe like.

The query system 214 enables users to run queries against the storeddata to retrieve events that meet criteria specified in a query, such ascontaining certain keywords or having specific values in defined fields.FIG. 13B illustrates the manner in which keyword searches and fieldsearches are processed in accordance with disclosed embodiments.

If a user inputs a search query into search bar 1310 that includes onlykeywords (also known as “tokens”), e.g., the keyword “error” or“warning”, the query system 214 of the data intake and query system 108can search for those keywords directly in the event data 1311 stored inthe raw record data store. Note that while FIG. 13B only illustratesfour events 1312, 1313, 1314, 1315, the raw record data store(corresponding to data store 208 in FIG. 2) may contain records formillions of events.

As disclosed above, the indexing system 212 can optionally generate akeyword index to facilitate fast keyword searching for event data. Theindexing system 212 can include the identified keywords in an index,which associates each stored keyword with reference pointers to eventscontaining that keyword (or to locations within events where thatkeyword is located, other location identifiers, etc.). When the querysystem 214 subsequently receives a keyword-based query, the query system214 can access the keyword index to quickly identify events containingthe keyword. For example, if the keyword “HTTP” was indexed by theindexing system 212 at index time, and the user searches for the keyword“HTTP”, the events 1312, 1313, and 1314, will be identified based on theresults returned from the keyword index. As noted above, the indexcontains reference pointers to the events containing the keyword, whichallows for efficient retrieval of the relevant events from the rawrecord data store.

If a user searches for a keyword that has not been indexed by theindexing system 212, the data intake and query system 108 maynevertheless be able to retrieve the events by searching the event datafor the keyword in the raw record data store directly as shown in FIG.13B. For example, if a user searches for the keyword “frank”, and thename “frank” has not been indexed at search time, the query system 214can search the event data directly and return the first event 1312. Notethat whether the keyword has been indexed at index time or search timeor not, in both cases the raw data with the events 1311 is accessed fromthe raw data record store to service the keyword search. In the casewhere the keyword has been indexed, the index will contain a referencepointer that will allow for a more efficient retrieval of the event datafrom the data store. If the keyword has not been indexed, the querysystem 214 can search through the records in the data store to servicethe search.

In most cases, however, in addition to keywords, a user's search willalso include fields. The term “field” refers to a location in the eventdata containing one or more values for a specific data item. Often, afield is a value with a fixed, delimited position on a line, or a nameand value pair, where there is a single value to each field name. Afield can also be multivalued, that is, it can appear more than once inan event and have a different value for each appearance, e.g., emailaddress fields. Fields are searchable by the field name or fieldname-value pairs. Some examples of fields are “clientip” for IPaddresses accessing a web server, or the “From” and “To” fields in emailaddresses.

By way of further example, consider the search, “status=404”. Thissearch query finds events with “status” fields that have a value of“404.” When the search is run, the query system 214 does not look forevents with any other “status” value. It also does not look for eventscontaining other fields that share “404” as a value. As a result, thesearch returns a set of results that are more focused than if “404” hadbeen used in the search string as part of a keyword search. Note alsothat fields can appear in events as “key=value” pairs such as“user_name=Bob.” But in most cases, field values appear in fixed,delimited positions without identifying keys. For example, the datastore may contain events where the “user_name” value always appears byitself after the time stamp as illustrated by the following string: “Nov15 09:33:22 evaemerson.”

The data intake and query system 108 advantageously allows for searchtime field extraction. In other words, fields can be extracted from theevent data at search time using late-binding schema as opposed to atdata ingestion time, which was a major limitation of the prior artsystems.

In response to receiving the search query, a search head 504 of thequery system 214 can use extraction rules to extract values for thefields associated with a field or fields in the event data beingsearched. The search head 504 can obtain extraction rules that specifyhow to extract a value for certain fields from an event. Extractionrules can comprise regex rules that specify how to extract values forthe relevant fields. In addition to specifying how to extract fieldvalues, the extraction rules may also include instructions for derivinga field value by performing a function on a character string or valueretrieved by the extraction rule. For example, a transformation rule maytruncate a character string, or convert the character string into adifferent data format. In some cases, the query itself can specify oneor more extraction rules.

FIG. 13B illustrates the manner in which configuration files may be usedto configure custom fields at search time in accordance with thedisclosed embodiments. In response to receiving a search query, the dataintake and query system 108 determines if the query references a“field.” For example, a query may request a list of events where the“clientip” field equals “127.0.0.1.” If the query itself does notspecify an extraction rule and if the field is not a metadata field,e.g., time, host, source, source type, etc., then in order to determinean extraction rule, the query system 214 may, in one or moreembodiments, need to locate configuration file 1316 during the executionof the search as shown in FIG. 13B.

Configuration file 1316 may contain extraction rules for all the variousfields that are not metadata fields, e.g., the “clientip” field. Theextraction rules may be inserted into the configuration file in avariety of ways. In some embodiments, the extraction rules can compriseregular expression rules that are manually entered in by the user.Regular expressions match patterns of characters in text and are usedfor extracting custom fields in text.

In one or more embodiments, as noted above, a field extractor may beconfigured to automatically generate extraction rules for certain fieldvalues in the events when the events are being created, indexed, orstored, or possibly at a later time. In one embodiment, a user may beable to dynamically create custom fields by highlighting portions of asample event that should be extracted as fields using a graphical userinterface. The system can then generate a regular expression thatextracts those fields from similar events and store the regularexpression as an extraction rule for the associated field in theconfiguration file 1316.

In some embodiments, the indexing system 212 can automatically discovercertain custom fields at index time and the regular expressions forthose fields will be automatically generated at index time and stored aspart of extraction rules in configuration file 1316. For example, fieldsthat appear in the event data as “key=value” pairs may be automaticallyextracted as part of an automatic field discovery process. Note thatthere may be several other ways of adding field definitions toconfiguration files in addition to the methods discussed herein.

The search head 504 can apply the extraction rules derived fromconfiguration file 1316 to event data that it receives from search nodes506. The search nodes 506 may apply the extraction rules from theconfiguration file to events in an associated data store or commonstorage 216. Extraction rules can be applied to all the events in a datastore, or to a subset of the events that have been filtered based onsome criteria (e.g., event time stamp values, etc.). Extraction rulescan be used to extract one or more values for a field from events byparsing the event data and examining the event data for one or morepatterns of characters, numbers, delimiters, etc., that indicate wherethe field begins and, optionally, ends.

In one more embodiments, the extraction rule in configuration file 1316will also need to define the type or set of events that the rule appliesto. Because the raw record data store will contain events from multipleheterogeneous sources, multiple events may contain the same fields indifferent locations because of discrepancies in the format of the datagenerated by the various sources. Furthermore, certain events may notcontain a particular field at all. For example, event 1315 also contains“clientip” field, however, the “clientip” field is in a different formatfrom events 1312, 1313, and 1314. To address the discrepancies in theformat and content of the different types of events, the configurationfile will also need to specify the set of events that an extraction ruleapplies to, e.g., extraction rule 1317 specifies a rule for filtering bythe type of event and contains a regular expression for parsing out thefield value. Accordingly, each extraction rule can pertain to only aparticular type of event. If a particular field, e.g., “clientip” occursin multiple types of events, each of those types of events can have itsown corresponding extraction rule in the configuration file 1316 andeach of the extraction rules would comprise a different regularexpression to parse out the associated field value. The most common wayto categorize events is by source type because events generated by aparticular source can have the same format.

The field extraction rules stored in configuration file 1316 performsearch-time field extractions. For example, for a query that requests alist of events with source type “access_combined” where the “clientip”field equals “127.0.0.1,” the query system 214 can first locate theconfiguration file 1316 to retrieve extraction rule 1317 that allows itto extract values associated with the “clientip” field from the eventdata 1320 “where the source type is “access_combined. After the“clientip” field has been extracted from all the events comprising the“clientip” field where the source type is “access_combined,” the querysystem 214 can then execute the field criteria by performing the compareoperation to filter out the events where the “clientip” field equals“127.0.0.1.” In the example shown in FIG. 13B, the events 1312, 1313,and 1314 would be returned in response to the user query. In thismanner, the query system 214 can service queries containing fieldcriteria in addition to queries containing keyword criteria (asexplained above).

In some embodiments, the configuration file 1316 can be created duringindexing. It may either be manually created by the user or automaticallygenerated with certain predetermined field extraction rules. Asdiscussed above, the events may be distributed across several datastores in common storage 216, wherein various indexing nodes 404 may beresponsible for storing the events in the common storage 216 and varioussearch nodes 506 may be responsible for searching the events containedin common storage 216.

The ability to add schema to the configuration file at search timeresults in increased efficiency. A user can create new fields at searchtime and simply add field definitions to the configuration file. As auser learns more about the data in the events, the user can continue torefine the late-binding schema by adding new fields, deleting fields, ormodifying the field extraction rules in the configuration file for usethe next time the schema is used by the system. Because the data intakeand query system 108 maintains the underlying raw data and useslate-binding schema for searching the raw data, it enables a user tocontinue investigating and learn valuable insights about the raw datalong after data ingestion time.

The ability to add multiple field definitions to the configuration fileat search time also results in increased flexibility. For example,multiple field definitions can be added to the configuration file tocapture the same field across events generated by different sourcetypes. This allows the data intake and query system 108 to search andcorrelate data across heterogeneous sources flexibly and efficiently.

Further, by providing the field definitions for the queried fields atsearch time, the configuration file 1316 allows the record data store tobe field searchable. In other words, the raw record data store can besearched using keywords as well as fields, wherein the fields aresearchable name/value pairings that distinguish one event from anotherand can be defined in configuration file 1316 using extraction rules. Incomparison to a search containing field names, a keyword search does notneed the configuration file and can search the event data directly asshown in FIG. 13B.

It should also be noted that any events filtered out by performing asearch-time field extraction using a configuration file 1316 can befurther processed by directing the results of the filtering step to aprocessing step using a pipelined search language. Using the priorexample, a user can pipeline the results of the compare step to anaggregate function by asking the query system 214 to count the number ofevents where the “clientip” field equals “127.0.0.1.”

4.8. Data Models

A data model is a hierarchically structured search-time mapping ofsemantic knowledge about one or more datasets. It encodes the domainknowledge used to build a variety of specialized searches of thosedatasets. Those searches, in turn, can be used to generate reports.

A data model is composed of one or more “objects” (or “data modelobjects”) that define or otherwise correspond to a specific set of data.An object is defined by constraints and attributes. An object'sconstraints are search criteria that define the set of events to beoperated on by running a search having that search criteria at the timethe data model is selected. An object's attributes are the set of fieldsto be exposed for operating on that set of events generated by thesearch criteria.

Objects in data models can be arranged hierarchically in parent/childrelationships. Each child object represents a subset of the datasetcovered by its parent object. The top-level objects in data models arecollectively referred to as “root objects.”

Child objects have inheritance. Child objects inherit constraints andattributes from their parent objects and may have additional constraintsand attributes of their own. Child objects provide a way of filteringevents from parent objects. Because a child object may provide anadditional constraint in addition to the constraints it has inheritedfrom its parent object, the dataset it represents may be a subset of thedataset that its parent represents. For example, a first data modelobject may define a broad set of data pertaining to e-mail activitygenerally, and another data model object may define specific datasetswithin the broad dataset, such as a subset of the e-mail data pertainingspecifically to e-mails sent. For example, a user can simply select an“e-mail activity” data model object to access a dataset relating toe-mails generally (e.g., sent or received), or select an “e-mails sent”data model object (or data sub-model object) to access a datasetrelating to e-mails sent.

Because a data model object is defined by its constraints (e.g., a setof search criteria) and attributes (e.g., a set of fields), a data modelobject can be used to quickly search data to identify a set of eventsand to identify a set of fields to be associated with the set of events.For example, an “e-mails sent” data model object may specify a searchfor events relating to e-mails that have been sent, and specify a set offields that are associated with the events. Thus, a user can retrieveand use the “e-mails sent” data model object to quickly search sourcedata for events relating to sent e-mails, and may be provided with alisting of the set of fields relevant to the events in a user interfacescreen.

Examples of data models can include electronic mail, authentication,databases, intrusion detection, malware, application state, alerts,compute inventory, network sessions, network traffic, performance,audits, updates, vulnerabilities, etc. Data models and their objects canbe designed by knowledge managers in an organization, and they canenable downstream users to quickly focus on a specific set of data. Auser can iteratively applies a model development tool to prepare a querythat defines a subset of events and assigns an object name to thatsubset. A child subset is created by further limiting a query thatgenerated a parent subset.

Data definitions in associated schemas can be taken from the commoninformation model (CIM) or can be devised for a particular schema andoptionally added to the CIM. Child objects inherit fields from parentsand can include fields not present in parents. A model developer canselect fewer extraction rules than are available for the sourcesreturned by the query that defines events belonging to a model.Selecting a limited set of extraction rules can be a tool forsimplifying and focusing the data model, while allowing a userflexibility to explore the data subset. Development of a data model isfurther explained in U.S. Pat. Nos. 8,788,525 and 8,788,526, bothentitled “DATA MODEL FOR MACHINE DATA FOR SEMANTIC SEARCH”, both issuedon 22 Jul. 2014, U.S. Pat. No. 8,983,994, entitled “GENERATION OF A DATAMODEL FOR SEARCHING MACHINE DATA”, issued on 17 Mar. 2015, U.S. Pat. No.9,128,980, entitled “GENERATION OF A DATA MODEL APPLIED TO QUERIES”,issued on 8 Sep. 2015, and U.S. Pat. No. 9,589,012, entitled “GENERATIONOF A DATA MODEL APPLIED TO OBJECT QUERIES”, issued on 7 Mar. 2017, eachof which is hereby incorporated by reference in its entirety for allpurposes.

A data model can also include reports. One or more report formats can beassociated with a particular data model and be made available to runagainst the data model. A user can use child objects to design reportswith object datasets that already have extraneous data pre-filtered out.In some embodiments, the data intake and query system 108 provides theuser with the ability to produce reports (e.g., a table, chart,visualization, etc.) without having to enter SPL, SQL, or other querylanguage terms into a search screen. Data models are used as the basisfor the search feature.

Data models may be selected in a report generation interface. The reportgenerator supports drag-and-drop organization of fields to be summarizedin a report. When a model is selected, the fields with availableextraction rules are made available for use in the report. The user mayrefine and/or filter search results to produce more precise reports. Theuser may select some fields for organizing the report and select otherfields for providing detail according to the report organization. Forexample, “region” and “salesperson” are fields used for organizing thereport and sales data can be summarized (subtotaled and totaled) withinthis organization. The report generator allows the user to specify oneor more fields within events and apply statistical analysis on valuesextracted from the specified one or more fields. The report generatormay aggregate search results across sets of events and generatestatistics based on aggregated search results. Building reports usingthe report generation interface is further explained in U.S. patentapplication Ser. No. 14/503,335, entitled “GENERATING REPORTS FROMUNSTRUCTURED DATA”, filed on 30 Sep. 2014, and which is herebyincorporated by reference in its entirety for all purposes. Datavisualizations also can be generated in a variety of formats, byreference to the data model. Reports, data visualizations, and datamodel objects can be saved and associated with the data model for futureuse. The data model object may be used to perform searches of otherdata, generate reports, etc. The report generation process may be drivenby a predefined data model object, such as a data model object definedand/or saved via a reporting application or a data model object obtainedfrom another source. A user can load a saved data model object using areport editor. For example, the initial search query and fields used todrive the report editor may be obtained from a data model object. Thedata model object that is used to drive a report generation process maydefine a search and a set of fields. Upon loading of the data modelobject, the report generation process may enable a user to use thefields (e.g., the fields defined by the data model object) to definecriteria for a report (e.g., filters, split rows/columns, aggregates,etc.) and the search may be used to identify events (e.g., to identifyevents responsive to the search) used to generate the report. That is,for example, if a data model object is selected to drive a reporteditor, the graphical user interface of the report editor may enable auser to define reporting criteria for the report using the fieldsassociated with the selected data model object, and the events used togenerate the report may be constrained to the events that match, orotherwise satisfy, the search constraints of the selected data modelobject.

4.9. Acceleration Techniques

The above-described system provides significant flexibility by enablinga user to analyze massive quantities of minimally-processed data “on thefly” at search time using a late-binding schema, instead of storingpre-specified portions of the data in a database at ingestion time. Thisflexibility enables a user to see valuable insights, correlate data, andperform subsequent queries to examine interesting aspects of the datathat may not have been apparent at ingestion time.

However, performing extraction and analysis operations at search timecan involve a large amount of data and require a large number ofcomputational operations, which can cause delays in processing thequeries. Advantageously, the data intake and query system 108 alsoemploys a number of unique acceleration techniques that have beendeveloped to speed up analysis operations performed at search time.These techniques include: (1) performing search operations in parallelusing multiple search nodes 506; (2) using a keyword index; (3) using ahigh performance analytics store; and (4) accelerating the process ofgenerating reports. These novel techniques are described in more detailbelow.

4.9.1. Aggregation Technique

To facilitate faster query processing, a query can be structured suchthat multiple search nodes 506 perform the query in parallel, whileaggregation of search results from the multiple search nodes 506 isperformed at the search head 504. For example, FIG. 14 is an examplesearch query received from a client and executed by search nodes 506, inaccordance with example embodiments. FIG. 14 illustrates how a searchquery 1402 received from a client at a search head 504 can split intotwo phases, including: (1) subtasks 1404 (e.g., data retrieval or simplefiltering) that may be performed in parallel by search nodes 506 forexecution, and (2) a search results aggregation operation 1406 to beexecuted by the search head 504 when the results are ultimatelycollected from the search nodes 506.

During operation, upon receiving search query 1402, a search head 504determines that a portion of the operations involved with the searchquery may be performed locally by the search head 504. The search head504 modifies search query 1402 by substituting “stats” (create aggregatestatistics over results sets received from the search nodes 506 at thesearch head 504) with “prestats” (create statistics by the search node506 from local results set) to produce search query 1404, and thendistributes search query 1404 to distributed search nodes 506, which arealso referred to as “search peers” or “peer search nodes.” Note thatsearch queries may generally specify search criteria or operations to beperformed on events that meet the search criteria. Search queries mayalso specify field names, as well as search criteria for the values inthe fields or operations to be performed on the values in the fields.Moreover, the search head 504 may distribute the full search query tothe search peers, or may alternatively distribute a modified version(e.g., a more restricted version) of the search query to the searchpeers. In this example, the search nodes 506 are responsible forproducing the results and sending them to the search head 504. After thesearch nodes 506 return the results to the search head 504, the searchhead 504 aggregates the received results 1406 to form a single searchresult set. By executing the query in this manner, the systemeffectively distributes the computational operations across the searchnodes 506 while minimizing data transfers.

4.9.2. Keyword Index

As described herein, the data intake and query system 108 can constructand maintain one or more keyword indexes to quickly identify eventscontaining specific keywords. This technique can greatly speed up theprocessing of queries involving specific keywords. As mentioned above,to build a keyword index, an indexing node 404 first identifies a set ofkeywords. Then, the indexing node 404 includes the identified keywordsin an index, which associates each stored keyword with references toevents containing that keyword, or to locations within events where thatkeyword is located. When the query system 214 subsequently receives akeyword-based query, the indexer can access the keyword index to quicklyidentify events containing the keyword.

4.9.3. High Performance Analytics Store

To speed up certain types of queries, some embodiments of data intakeand query system 108 create a high performance analytics store, which isreferred to as a “summarization table,” that contains entries forspecific field-value pairs. Each of these entries keeps track ofinstances of a specific value in a specific field in the events andincludes references to events containing the specific value in thespecific field. For example, an example entry in a summarization tablecan keep track of occurrences of the value “94107” in a “ZIP code” fieldof a set of events and the entry includes references to all of theevents that contain the value “94107” in the ZIP code field. Thisoptimization technique enables the system to quickly process queriesthat seek to determine how many events have a particular value for aparticular field. To this end, the system can examine the entry in thesummarization table to count instances of the specific value in thefield without having to go through the individual events or perform dataextractions at search time. Also, if the system needs to process allevents that have a specific field-value combination, the system can usethe references in the summarization table entry to directly access theevents to extract further information without having to search all ofthe events to find the specific field-value combination at search time.

In some embodiments, the system maintains a separate summarization tablefor each of the above-described time-specific buckets that stores eventsfor a specific time range. A bucket-specific summarization tableincludes entries for specific field-value combinations that occur inevents in the specific bucket. Alternatively, the system can maintain asummarization table for the common storage 216, one or more data stores218 of the common storage 216, buckets cached on a search node 506, etc.The different summarization tables can include entries for the events inthe common storage 216, certain data stores 218 in the common storage216, or data stores associated with a particular search node 506, etc.

The summarization table can be populated by running a periodic querythat scans a set of events to find instances of a specific field-valuecombination, or alternatively instances of all field-value combinationsfor a specific field. A periodic query can be initiated by a user, orcan be scheduled to occur automatically at specific time intervals. Aperiodic query can also be automatically launched in response to a querythat asks for a specific field-value combination.

In some cases, when the summarization tables may not cover all of theevents that are relevant to a query, the system can use thesummarization tables to obtain partial results for the events that arecovered by summarization tables, but may also have to search throughother events that are not covered by the summarization tables to produceadditional results. These additional results can then be combined withthe partial results to produce a final set of results for the query. Thesummarization table and associated techniques are described in moredetail in U.S. Pat. No. 8,682,925, entitled “DISTRIBUTED HIGHPERFORMANCE ANALYTICS STORE”, issued on 25 Mar. 2014, U.S. Pat. No.9,128,985, entitled “SUPPLEMENTING A HIGH PERFORMANCE ANALYTICS STOREWITH EVALUATION OF INDIVIDUAL EVENTS TO RESPOND TO AN EVENT QUERY”,issued on 8 Sep. 2015, and U.S. patent application Ser. No. 14/815,973,entitled “GENERATING AND STORING SUMMARIZATION TABLES FOR SETS OFSEARCHABLE EVENTS”, filed on 1 Aug. 2015, each of which is herebyincorporated by reference in its entirety for all purposes.

To speed up certain types of queries, e.g., frequently encounteredqueries or computationally intensive queries, some embodiments of dataintake and query system 108 create a high performance analytics store,which is referred to as a “summarization table,” (also referred to as a“lexicon” or “inverted index”) that contains entries for specificfield-value pairs. Each of these entries keeps track of instances of aspecific value in a specific field in the event data and includesreferences to events containing the specific value in the specificfield. For example, an example entry in an inverted index can keep trackof occurrences of the value “94107” in a “ZIP code” field of a set ofevents and the entry includes references to all of the events thatcontain the value “94107” in the ZIP code field. Creating the invertedindex data structure avoids needing to incur the computational overheadeach time a statistical query needs to be run on a frequentlyencountered field-value pair. In order to expedite queries, in certainembodiments, the query system 214 can employ the inverted index separatefrom the raw record data store to generate responses to the receivedqueries.

Note that the term “summarization table” or “inverted index” as usedherein is a data structure that may be generated by the indexing system212 that includes at least field names and field values that have beenextracted and/or indexed from event records. An inverted index may alsoinclude reference values that point to the location(s) in the fieldsearchable data store where the event records that include the field maybe found. Also, an inverted index may be stored using variouscompression techniques to reduce its storage size.

Further, note that the term “reference value” (also referred to as a“posting value”) as used herein is a value that references the locationof a source record in the field searchable data store. In someembodiments, the reference value may include additional informationabout each record, such as timestamps, record size, meta-data, or thelike. Each reference value may be a unique identifier which may be usedto access the event data directly in the field searchable data store. Insome embodiments, the reference values may be ordered based on eachevent record's timestamp. For example, if numbers are used asidentifiers, they may be sorted so event records having a latertimestamp always have a lower valued identifier than event records withan earlier timestamp, or vice-versa. Reference values are often includedin inverted indexes for retrieving and/or identifying event records.

In one or more embodiments, an inverted index is generated in responseto a user-initiated collection query. The term “collection query” asused herein refers to queries that include commands that generatesummarization information and inverted indexes (or summarization tables)from event records stored in the field searchable data store.

Note that a collection query is a special type of query that can beuser-generated and is used to create an inverted index. A collectionquery is not the same as a query that is used to call up or invoke apre-existing inverted index. In one or more embodiments, a query cancomprise an initial step that calls up a pre-generated inverted index onwhich further filtering and processing can be performed. For example,referring back to FIG. 12B, a set of events can be generated at block1240 by either using a “collection” query to create a new inverted indexor by calling up a pre-generated inverted index. A query with severalpipelined steps will start with a pre-generated index to accelerate thequery.

FIG. 13C illustrates the manner in which an inverted index is createdand used in accordance with the disclosed embodiments. As shown in FIG.13C, an inverted index 1322 can be created in response to auser-initiated collection query using the event data 1323 stored in theraw record data store. For example, a non-limiting example of acollection query may include “collect clientip=127.0.0.1” which mayresult in an inverted index 1322 being generated from the event data1323 as shown in FIG. 13C. Each entry in inverted index 1322 includes anevent reference value that references the location of a source record inthe field searchable data store. The reference value may be used toaccess the original event record directly from the field searchable datastore.

In one or more embodiments, if one or more of the queries is acollection query, the one or more search nodes 506 may generatesummarization information based on the fields of the event recordslocated in the field searchable data store. In at least one of thevarious embodiments, one or more of the fields used in the summarizationinformation may be listed in the collection query and/or they may bedetermined based on terms included in the collection query. For example,a collection query may include an explicit list of fields to summarize.Or, in at least one of the various embodiments, a collection query mayinclude terms or expressions that explicitly define the fields, e.g.,using regex rules. In FIG. 13C, prior to running the collection querythat generates the inverted index 1322, the field name “clientip” mayneed to be defined in a configuration file by specifying the“access_combined” source type and a regular expression rule to parse outthe client IP address. Alternatively, the collection query may containan explicit definition for the field name “clientip” which may obviatethe need to reference the configuration file at search time.

In one or more embodiments, collection queries may be saved andscheduled to run periodically. These scheduled collection queries mayperiodically update the summarization information corresponding to thequery. For example, if the collection query that generates invertedindex 1322 is scheduled to run periodically, one or more search nodes506 can periodically search through the relevant buckets to updateinverted index 1322 with event data for any new events with the“clientip” value of “127.0.0.1.”

In some embodiments, the inverted indexes that include fields, values,and reference value (e.g., inverted index 1322) for event records may beincluded in the summarization information provided to the user. In otherembodiments, a user may not be interested in specific fields and valuescontained in the inverted index, but may need to perform a statisticalquery on the data in the inverted index. For example, referencing theexample of FIG. 13C rather than viewing the fields within the invertedindex 1322, a user may want to generate a count of all client requestsfrom IP address “127.0.0.1.” In this case, the query system 214 cansimply return a result of “4” rather than including details about theinverted index 1322 in the information provided to the user.

The pipelined search language, e.g., SPL of the SPLUNK® ENTERPRISEsystem can be used to pipe the contents of an inverted index to astatistical query using the “stats” command for example A “stats” queryrefers to queries that generate result sets that may produce aggregateand statistical results from event records, e.g., average, mean, max,min, rms, etc. Where sufficient information is available in an invertedindex, a “stats” query may generate their result sets rapidly from thesummarization information available in the inverted index rather thandirectly scanning event records. For example, the contents of invertedindex 1322 can be pipelined to a stats query, e.g., a “count” functionthat counts the number of entries in the inverted index and returns avalue of “4.” In this way, inverted indexes may enable various statsqueries to be performed absent scanning or search the event records.Accordingly, this optimization technique enables the system to quicklyprocess queries that seek to determine how many events have a particularvalue for a particular field. To this end, the system can examine theentry in the inverted index to count instances of the specific value inthe field without having to go through the individual events or performdata extractions at search time.

In some embodiments, the system maintains a separate inverted index foreach of the above-described time-specific buckets that stores events fora specific time range. A bucket-specific inverted index includes entriesfor specific field-value combinations that occur in events in thespecific bucket. Alternatively, the system can maintain a separateinverted index for one or more data stores 218 of common storage 216, anindexing node 404, or a search node 506. The specific inverted indexescan include entries for the events in the one or more data stores 218 ordata store associated with the indexing nodes 404 or search node 506. Insome embodiments, if one or more of the queries is a stats query, asearch node 506 can generate a partial result set from previouslygenerated summarization information. The partial result sets may bereturned to the search head 504 that received the query and combinedinto a single result set for the query.

As mentioned above, the inverted index can be populated by running aperiodic query that scans a set of events to find instances of aspecific field-value combination, or alternatively instances of allfield-value combinations for a specific field. A periodic query can beinitiated by a user, or can be scheduled to occur automatically atspecific time intervals. A periodic query can also be automaticallylaunched in response to a query that asks for a specific field-valuecombination. In some embodiments, if summarization information is absentfrom a search node 506 that includes responsive event records, furtheractions may be taken, such as, the summarization information maygenerated on the fly, warnings may be provided the user, the collectionquery operation may be halted, the absence of summarization informationmay be ignored, or the like, or combination thereof.

In one or more embodiments, an inverted index may be set up to updatecontinually. For example, the query may ask for the inverted index toupdate its result periodically, e.g., every hour. In such instances, theinverted index may be a dynamic data structure that is regularly updatedto include information regarding incoming events.

4.9.3.1. Extracting Event Data Using Posting

In one or more embodiments, if the system needs to process all eventsthat have a specific field-value combination, the system can use thereferences in the inverted index entry to directly access the events toextract further information without having to search all of the eventsto find the specific field-value combination at search time. In otherwords, the system can use the reference values to locate the associatedevent data in the field searchable data store and extract furtherinformation from those events, e.g., extract further field values fromthe events for purposes of filtering or processing or both.

The information extracted from the event data using the reference valuescan be directed for further filtering or processing in a query using thepipeline search language. The pipelined search language will, in oneembodiment, include syntax that can direct the initial filtering step ina query to an inverted index. In one embodiment, a user would includesyntax in the query that explicitly directs the initial searching orfiltering step to the inverted index.

Referencing the example in FIG. 11C, if the user determines that sheneeds the user id fields associated with the client requests from IPaddress “127.0.0.1,” instead of incurring the computational overhead ofperforming a brand new search or re-generating the inverted index withan additional field, the user can generate a query that explicitlydirects or pipes the contents of the already generated inverted index1322 to another filtering step requesting the user ids for the entriesin inverted index 1322 where the server response time is greater than“0.0900” microseconds. The query system 214 can use the reference valuesstored in inverted index 1322 to retrieve the event data from the fieldsearchable data store, filter the results based on the “response time”field values and, further, extract the user id field from the resultingevent data to return to the user. In the present instance, the user ids“frank” and “eliza” would be returned to the user from the generatedresults table 1325.

In one embodiment, the same methodology can be used to pipe the contentsof the inverted index to a processing step. In other words, the user isable to use the inverted index to efficiently and quickly performaggregate functions on field values that were not part of the initiallygenerated inverted index. For example, a user may want to determine anaverage object size (size of the requested gif) requested by clientsfrom IP address “127.0.0.1.” In this case, the query system 214 canagain use the reference values stored in inverted index 1322 to retrievethe event data from the field searchable data store and, further,extract the object size field values from the associated events 1331,1332, 1333 and 1334. Once, the corresponding object sizes have beenextracted (i.e. 2326, 2900, 2920, and 5000), the average can be computedand returned to the user.

In one embodiment, instead of explicitly invoking the inverted index ina user-generated query, e.g., by the use of special commands or syntax,the SPLUNK® ENTERPRISE system can be configured to automaticallydetermine if any prior-generated inverted index can be used to expeditea user query. For example, the user's query may request the averageobject size (size of the requested gif) requested by clients from IPaddress “127.0.0.1.” without any reference to or use of inverted index1322. The query system 214, in this case, can automatically determinethat an inverted index 1322 already exists in the system that couldexpedite this query. In one embodiment, prior to running any searchcomprising a field-value pair, for example, a query system 214 cansearch though all the existing inverted indexes to determine if apre-generated inverted index could be used to expedite the searchcomprising the field-value pair. Accordingly, the query system 214 canautomatically use the pre-generated inverted index, e.g., index 1322 togenerate the results without any user-involvement that directs the useof the index.

Using the reference values in an inverted index to be able to directlyaccess the event data in the field searchable data store and extractfurther information from the associated event data for further filteringand processing is highly advantageous because it avoids incurring thecomputation overhead of regenerating the inverted index with additionalfields or performing a new search.

The data intake and query system 108 includes an intake system 210 thatreceives data from a variety of input data sources, and an indexingsystem 212 that processes and stores the data in one or more data storesor common storage 216. By distributing events among the data stores 218of common storage 213, the query system 214 can analyze events for aquery in parallel. In some embodiments, the data intake and query system108 can maintain a separate and respective inverted index for each ofthe above-described time-specific buckets that stores events for aspecific time range. A bucket-specific inverted index includes entriesfor specific field-value combinations that occur in events in thespecific bucket. As explained above, a search head 504 can correlate andsynthesize data from across the various buckets and search nodes 506.

This feature advantageously expedites searches because instead ofperforming a computationally intensive search in a centrally locatedinverted index that catalogues all the relevant events, a search node506 is able to directly search an inverted index stored in a bucketassociated with the time-range specified in the query. This allows thesearch to be performed in parallel across the various search nodes 506.Further, if the query requests further filtering or processing to beconducted on the event data referenced by the locally storedbucket-specific inverted index, the search node 506 is able to simplyaccess the event records stored in the associated bucket for furtherfiltering and processing instead of needing to access a centralrepository of event records, which would dramatically add to thecomputational overhead.

In one embodiment, there may be multiple buckets associated with thetime-range specified in a query. If the query is directed to an invertedindex, or if the query system 214 automatically determines that using aninverted index can expedite the processing of the query, the searchnodes 506 can search through each of the inverted indexes associatedwith the buckets for the specified time-range. This feature allows theHigh Performance Analytics Store to be scaled easily.

FIG. 13D is a flow diagram illustrating an embodiment of a routineimplemented by one or more computing devices of the data intake andquery system for using an inverted index in a pipelined search query todetermine a set of event data that can be further limited by filteringor processing. For example, the routine can be implemented by any one orany combination of the search head 504, search node 506, search master512, or search manager 514, etc. However, for simplicity, referencebelow is made to the query system 214 performing the various steps ofthe routine.

At block 1342, a query is received by a data intake and query system108. In some embodiments, the query can be received as a user generatedquery entered into search bar of a graphical user search interface. Thesearch interface also includes a time range control element that enablesspecification of a time range for the query.

At block 1344, an inverted index is retrieved. Note, that the invertedindex can be retrieved in response to an explicit user search commandinputted as part of the user generated query. Alternatively, a querysystem 214 can be configured to automatically use an inverted index ifit determines that using the inverted index would expedite the servicingof the user generated query. Each of the entries in an inverted indexkeeps track of instances of a specific value in a specific field in theevent data and includes references to events containing the specificvalue in the specific field. In order to expedite queries, in someembodiments, the query system 214 employs the inverted index separatefrom the raw record data store to generate responses to the receivedqueries.

At block 1346, the query system 214 determines if the query containsfurther filtering and processing steps. If the query contains no furthercommands, then, in one embodiment, summarization information can beprovided to the user at block 1354.

If, however, the query does contain further filtering and processingcommands, then at block 1348, the query system 214 determines if thecommands relate to further filtering or processing of the data extractedas part of the inverted index or whether the commands are directed tousing the inverted index as an initial filtering step to further filterand process event data referenced by the entries in the inverted index.If the query can be completed using data already in the generatedinverted index, then the further filtering or processing steps, e.g., a“count” number of records function, “average” number of records per houretc. are performed and the results are provided to the user at block1350.

If, however, the query references fields that are not extracted in theinverted index, the query system 214 can access event data pointed to bythe reference values in the inverted index to retrieve any furtherinformation required at block 1356. Subsequently, any further filteringor processing steps are performed on the fields extracted directly fromthe event data and the results are provided to the user at step 1358.

4.9.4. Accelerating Report Generation

In some embodiments, a data server system such as the data intake andquery system 108 can accelerate the process of periodically generatingupdated reports based on query results. To accelerate this process, asummarization engine can automatically examine the query to determinewhether generation of updated reports can be accelerated by creatingintermediate summaries. If reports can be accelerated, the summarizationengine periodically generates a summary covering data obtained during alatest non-overlapping time period. For example, where the query seeksevents meeting a specified criteria, a summary for the time period mayonly include events within the time period that meet the specifiedcriteria. Similarly, if the query seeks statistics calculated from theevents, such as the number of events that match the specified criteria,then the summary for the time period includes the number of events inthe period that match the specified criteria.

In addition to the creation of the summaries, the summarization engineschedules the periodic updating of the report associated with the query.During each scheduled report update, the query system 214 determineswhether intermediate summaries have been generated covering portions ofthe time period covered by the report update. If so, then the report isgenerated based on the information contained in the summaries. Also, ifadditional event data has been received and has not yet been summarized,and is required to generate the complete report, the query can be run onthese additional events. Then, the results returned by this query on theadditional events, along with the partial results obtained from theintermediate summaries, can be combined to generate the updated report.This process is repeated each time the report is updated. Alternatively,if the system stores events in buckets covering specific time ranges,then the summaries can be generated on a bucket-by-bucket basis. Notethat producing intermediate summaries can save the work involved inre-running the query for previous time periods, so advantageously onlythe newer events needs to be processed while generating an updatedreport. These report acceleration techniques are described in moredetail in U.S. Pat. No. 8,589,403, entitled “COMPRESSED JOURNALING INEVENT TRACKING FILES FOR METADATA RECOVERY AND REPLICATION”, issued on19 Nov. 2013, U.S. Pat. No. 8,412,696, entitled “REAL TIME SEARCHING ANDREPORTING”, issued on 2 Apr. 2011, and U.S. Pat. Nos. 8,589,375 and8,589,432, both also entitled “REAL TIME SEARCHING AND REPORTING”, bothissued on 19 Nov. 2013, each of which is hereby incorporated byreference in its entirety for all purposes.

4.10. Security Features

The data intake and query system 108 provides various schemas,dashboards, and visualizations that simplify developers' tasks to createapplications with additional capabilities. One such application is thean enterprise security application, such as SPLUNK® ENTERPRISE SECURITY,which performs monitoring and alerting operations and includes analyticsto facilitate identifying both known and unknown security threats basedon large volumes of data stored by the data intake and query system 108.The enterprise security application provides the security practitionerwith visibility into security-relevant threats found in the enterpriseinfrastructure by capturing, monitoring, and reporting on data fromenterprise security devices, systems, and applications. Through the useof the data intake and query system 108 searching and reportingcapabilities, the enterprise security application provides a top-downand bottom-up view of an organization's security posture.

The enterprise security application can process many types ofsecurity-related information. In general, this security-relatedinformation can include any information that can be used to identifysecurity threats. For example, the security-related information caninclude network-related information, such as IP addresses, domain names,asset identifiers, network traffic volume, uniform resource locatorstrings, and source addresses. The process of detecting security threatsfor network-related information is further described in U.S. Pat. No.8,826,434, entitled “SECURITY THREAT DETECTION BASED ON INDICATIONS INBIG DATA OF ACCESS TO NEWLY REGISTERED DOMAINS”, issued on 2 Sep. 2014,U.S. Pat. No. 9,215,240, entitled “INVESTIGATIVE AND DYNAMIC DETECTIONOF POTENTIAL SECURITY-THREAT INDICATORS FROM EVENTS IN BIG DATA”, issuedon 15 Dec. 2015, U.S. Pat. No. 9,173,801, entitled “GRAPHIC DISPLAY OFSECURITY THREATS BASED ON INDICATIONS OF ACCESS TO NEWLY REGISTEREDDOMAINS”, issued on 3 Nov. 2015, U.S. Pat. No. 9,248,068, entitled“SECURITY THREAT DETECTION OF NEWLY REGISTERED DOMAINS”, issued on 2Feb. 2016, U.S. Pat. No. 9,426,172, entitled “SECURITY THREAT DETECTIONUSING DOMAIN NAME ACCESSES”, issued on 23 Aug. 2016, and U.S. Pat. No.9,432,396, entitled “SECURITY THREAT DETECTION USING DOMAIN NAMEREGISTRATIONS”, issued on 30 Aug. 2016, each of which is herebyincorporated by reference in its entirety for all purposes.Security-related information can also include malware infection data andsystem configuration information, as well as access control information,such as login/logout information and access failure notifications. Thesecurity-related information can originate from various sources within adata center, such as hosts, virtual machines, storage devices andsensors. The security-related information can also originate fromvarious sources in a network, such as routers, switches, email servers,proxy servers, gateways, firewalls and intrusion-detection systems.

The enterprise security application provides various visualizations toaid in discovering security threats, such as a “key indicators view”that enables a user to view security metrics, such as counts ofdifferent types of notable events. For example, FIG. 15 illustrates anexample key indicators view 1500 that comprises a dashboard, which candisplay a value 1501, for various security-related metrics, such asmalware infections 1502. It can also display a change in a metric value1503, which indicates that the number of malware infections increased by63 during the preceding interval. Key indicators view 1500 additionallydisplays a histogram panel 1504 that displays a histogram of notableevents organized by urgency values, and a histogram of notable eventsorganized by time intervals. This key indicators view is described infurther detail in pending U.S. patent application Ser. No. 13/956,338,entitled “KEY INDICATORS VIEW”, filed on 31 Jul. 2013, and which ishereby incorporated by reference in its entirety for all purposes.Additional disclosure regarding the security features is described inU.S. application Ser. No. 16/512,899, incorporated by reference hereinin its entirety.

4.11. Data Center Monitoring

As mentioned above, the data intake and query platform provides variousfeatures that simplify the developer's task to create variousapplications, including for data center monitoring. One such applicationis a virtual machine monitoring application, such as SPLUNK® APP FORVMWARE® that provides operational visibility into granular performancemetrics, logs, tasks and events, and topology from hosts, virtualmachines and virtual centers. It empowers administrators with anaccurate real-time picture of the health of the environment, proactivelyidentifying performance and capacity bottlenecks. Additional disclosureregarding the data center monitoring is described in U.S. applicationSer. No. 16/512,899, incorporated by reference herein in its entirety.

Additional disclosure regarding the use of performance metrics for datacenter monitoring is described in U.S. patent application Ser. No.14/167,316, entitled “CORRELATION FOR USER-SELECTED TIME RANGES OFVALUES FOR PERFORMANCE METRICS OF COMPONENTS IN ANINFORMATION-TECHNOLOGY ENVIRONMENT WITH LOG DATA FROM THATINFORMATION-TECHNOLOGY ENVIRONMENT”, filed on 29 Jan. 2014, and which ishereby incorporated by reference in its entirety for all purposes.Additional disclosure regarding a proactive monitoring tree is describedin further detail in U.S. Pat. No. 9,185,007, entitled “PROACTIVEMONITORING TREE WITH SEVERITY STATE SORTING”, issued on 10 Nov. 2015,and U.S. Pat. No. 9,426,045, also entitled “PROACTIVE MONITORING TREEWITH SEVERITY STATE SORTING”, issued on 23 Aug. 2016, each of which ishereby incorporated by reference in its entirety for all purposes.Additional disclosure regarding a user interface that can be used fordata center monitoring is described in more detail in U.S. patentapplication Ser. No. 14/167,316, entitled “CORRELATION FOR USER-SELECTEDTIME RANGES OF VALUES FOR PERFORMANCE METRICS OF COMPONENTS IN ANINFORMATION-TECHNOLOGY ENVIRONMENT WITH LOG DATA FROM THATINFORMATION-TECHNOLOGY ENVIRONMENT”, filed on 29 Jan. 2014, and which ishereby incorporated by reference in its entirety for all purposes.

4.12. IT Service Monitoring

As previously mentioned, the data intake and query platform providesvarious schemas, dashboards and visualizations that make it easy fordevelopers to create applications to provide additional capabilities.One such application is an IT monitoring application, such as SPLUNK® ITSERVICE INTELLIGENCE™, which performs monitoring and alertingoperations. The IT monitoring application also includes analytics tohelp an analyst diagnose the root cause of performance problems based onlarge volumes of data stored by the data intake and query system 108 ascorrelated to the various services an IT organization provides (aservice-centric view). This differs significantly from conventional ITmonitoring systems that lack the infrastructure to effectively store andanalyze large volumes of service-related events. Traditional servicemonitoring systems typically use fixed schemas to extract data frompre-defined fields at data ingestion time, wherein the extracted data istypically stored in a relational database. This data extraction processand associated reduction in data content that occurs at data ingestiontime inevitably hampers future investigations, when all of the originaldata may be needed to determine the root cause of or contributingfactors to a service issue.

In contrast, an IT monitoring application system stores large volumes ofminimally-processed service-related data at ingestion time for laterretrieval and analysis at search time, to perform regular monitoring, orto investigate a service issue. To facilitate this data retrievalprocess, the IT monitoring application enables a user to define an IToperations infrastructure from the perspective of the services itprovides. In this service-centric approach, a service such as corporatee-mail may be defined in terms of the entities employed to provide theservice, such as host machines and network devices. Each entity isdefined to include information for identifying all of the events thatpertains to the entity, whether produced by the entity itself or byanother machine, and considering the many various ways the entity may beidentified in machine data (such as by a URL, an IP address, or machinename). The service and entity definitions can organize events around aservice so that all of the events pertaining to that service can beeasily identified. This capability provides a foundation for theimplementation of Key Performance Indicators.

Additional disclosure regarding IT Service Monitoring is described inU.S. application Ser. No. 16/512,899, incorporated by reference hereinin its entirety.

4.13. Other Architectures

In view of the description above, it will be appreciated that thearchitecture disclosed herein, or elements of that architecture, may beimplemented independently from, or in conjunction with, otherarchitectures. For example, the Incorporated Applications disclose avariety of architectures wholly or partially compatible with thearchitecture of the present disclosure.

Generally speaking, one or more components of the data intake and querysystem 108 of the present disclosure can be used in combination with orto replace one or more components of the data intake and query system108 of the Incorporated Applications. For example, depending on theembodiment, the operations of the forwarder 204 and the ingestion buffer4802 of the Incorporated Applications can be performed by or replacedwith the intake system 210 of the present disclosure. The parsing,indexing, and storing operations (or other non-searching operations) ofthe indexers 206, 230 and indexing cache components 254 of theIncorporated Applications can be performed by or replaced with theindexing nodes 404 of the present disclosure. The storage operations ofthe data stores 208 of the Incorporated Applications can be performedusing the data stores 412 of the present disclosure (in some cases withthe data not being moved to common storage 216). The storage operationsof the common storage 4602, cloud storage 256, or global index 258 canbe performed by the common storage 216 of the present disclosure. Thestorage operations of the query acceleration data store 3308 can beperformed by the query acceleration data store 222 of the presentdisclosure.

As continuing examples, the search operations of the indexers 206, 230and indexing cache components 254 of the Incorporated Applications canbe performed by or replaced with the indexing nodes 404 in someembodiments or by the search nodes 506 in certain embodiments. Forexample, in some embodiments of certain architectures of theIncorporated Applications (e.g., one or more embodiments related toFIGS. 2, 3, 4, 18, 25, 27, 33, 46), the indexers 206, 230 and indexingcache components 254 of the Incorporated Applications may performparsing, indexing, storing, and at least some searching operations, andin embodiments of some architectures of the Incorporated Applications(e.g., one more embodiments related to FIG. 48), indexers 206, 230 andindexing cache components 254 of the Incorporated Applications performparsing, indexing, and storing operations, but do not perform searchingoperations. Accordingly, in some embodiments, some or all of thesearching operations described as being performed by the indexers 206,230 and indexing cache components 254 of the Incorporated Applicationscan be performed by the search nodes 506. For example, in embodimentsdescribed in the Incorporated Applications in which worker nodes 214,236, 246, 3306 perform searching operations in place of the indexers206, 230 or indexing cache components 254, the search nodes 506 canperform those operations. In certain embodiments, some or all of thesearching operations described as being performed by the indexers 206,230 and indexing cache components 254 of the Incorporated Applicationscan be performed by the indexing nodes 404. For example, in embodimentsdescribed in the Incorporated Applications in which the indexers 206,230 and indexing cache components 254 perform searching operations, theindexing nodes 404 can perform those operations.

As a further example, the query operations performed by the search heads210, 226, 244, daemons 210, 232, 252, search master 212, 234, 250,search process master 3302, search service provider 216, and querycoordinator 3304 of the Incorporated Applications, can be performed byor replaced with any one or any combination of the query system manager502, search head 504, search master 512, search manager 514, resourcemonitor 508, and/or the resource catalog 510. For example, thesecomponents can handle and coordinate the intake of queries, queryprocessing, identification of available nodes and resources, resourceallocation, query execution plan generation, assignment of queryoperations, combining query results, and providing query results to auser or a data store.

In certain embodiments, the query operations performed by the workernodes 214, 236, 246, 3306 of the Incorporated Applications can beperformed by or replaced with the search nodes 506 of the presentdisclosure. In some embodiments, the intake or ingestion operationsperformed by the worker nodes 214, 236, 246, 3306 of the IncorporatedApplications can be performed by or replaced with one or more componentsof the intake system 210.

Furthermore, it will be understood that some or all of the components ofthe architectures of the Incorporated Applications can be replaced withcomponents of the present disclosure. For example, in certainembodiments, the intake system 210 can be used in place of theforwarders 204 and/or ingestion buffer 4802 of one or more architecturesof the Incorporated Applications, with all other components of the oneor more architecture of the Incorporated Applications remaining thesame. As another example, in some embodiments the indexing nodes 404 canreplace the indexer 206 of one or more architectures of the IncorporatedApplications with all other components of the one or more architecturesof the Incorporated Applications remaining the same. Accordingly, itwill be understood that a variety of architectures can be designed usingone or more components of the data intake and query system 108 of thepresent disclosure in combination with one or more components of thedata intake and query system 108 of the Incorporated Applications.

Illustratively, the architecture depicted at FIG. 2 of the IncorporatedApplications may be modified to replace the forwarder 204 of thatarchitecture with the intake system 210 of the present disclosure. Inaddition, in some cases, the indexers 206 of the IncorporatedApplications can be replaced with the indexing nodes 404 of the presentdisclosure. In such embodiments, the indexing nodes 404 can retain thebuckets in the data stores 412 that they create rather than store thebuckets in common storage 216. Further, in the architecture depicted atFIG. 2 of the Incorporated Applications, the indexing nodes 404 of thepresent disclosure can be used to execute searches on the buckets storedin the data stores 412. In some embodiments, in the architecturedepicted at FIG. 2 of the Incorporated Applications, the partitionmanager 408 can receive data from one or more forwarders 204 of theIncorporated Applications. As additional forwarders 204 are added or asadditional data is supplied to the architecture depicted at FIG. 2 ofthe Incorporated Applications, the indexing node 404 can spawnadditional partition manager 408 and/or the indexing manager system 402can spawn additional indexing nodes 404. In addition, in certainembodiments, the bucket manager 414 may merge buckets in the data store414 or be omitted from the architecture depicted at FIG. 2 of theIncorporated Applications.

Furthermore, in certain embodiments, the search head 210 of theIncorporated Applications can be replaced with the search head 504 ofthe present disclosure. In some cases, as described herein, the searchhead 504 can use the search master 512 and search manager 514 to processand manager the queries. However, rather than communicating with searchnodes 506 to execute a query, the search head 504 can, depending on theembodiment, communicate with the indexers 206 of the IncorporatedApplications or the search nodes 404 to execute the query.

Similarly, the architecture of FIG. 3 of the Incorporated Applicationsmay be modified in a variety of ways to include one or more componentsof the data intake and query system 108 described herein. For example,the architecture of FIG. 3 of the Incorporated Applications may bemodified to include an intake system 210 in accordance with the presentdisclosure within the cloud-based data intake and query system 1006 ofthe Incorporated Applications, which intake system 210 may logicallyinclude or communicate with the forwarders 204 of the IncorporatedApplications. In addition, the indexing nodes 404 described herein maybe utilized in place of or to implement functionality similar to theindexers described with reference to FIG. 3 of the IncorporatedApplications. In addition, the architecture of FIG. 3 of theIncorporated Applications may be modified to include common storage 216and/or search nodes 506.

With respect to the architecture of FIGS. 4A and/or 4B of theIncorporated Applications, the intake system 210 described herein may beutilized in place of or to implement functionality similar to either orboth the forwarders 204 or the ERP processes 410 through 412 of theIncorporated Applications. Similarly, the indexing nodes 506 and thesearch head 504 described herein may be utilized in place of or toimplement functionality similar to the indexer 206 and search head 210,respectively. In some cases, the search manager 514 described herein canmanage the communications and interfacing between the indexer 206 andthe ERP processes 410 through 412.

With respect to the flow diagrams and functionality described in FIGS.5A-5C, 6A, 6B, 7A-7D, 8A, 8B, 9, 10, 11A-11D, 12-16, and 17A-17D of theIncorporated Applications, it will be understood that the processing andindexing operations described as being performed by the indexers 206 canbe performed by the indexing nodes 404, the search operations describedas being performed by the indexers 206 can be performed by the indexingnodes 404 or search nodes 506 (depending on the embodiment), and/or thesearching operations described as being performed by the search head210, can be performed by the search head 504 or other component of thequery system 214.

With reference to FIG. 18 of the Incorporated Applications, the indexingnodes 404 and search heads 504 described herein may be utilized in placeof or to implement functionality similar to the indexers 206 and searchhead 210, respectively. Similarly, the search master 512 and searchmanager 514 described herein may be utilized in place of or to implementfunctionality similar to the master 212 and the search service provider216, respectively, described with respect to FIG. 18 of the IncorporatedApplications. Further, the intake system 210 described herein may beutilized in place of or to implement ingestion functionality similar tothe ingestion functionality of the worker nodes 214 of the IncorporatedApplications. Similarly, the search nodes 506 described herein may beutilized in place of or to implement search functionality similar to thesearch functionality of the worker nodes 214 of the IncorporatedApplications.

With reference to FIG. 25 of the Incorporated Applications, the indexingnodes 404 and search heads 504 described herein may be utilized in placeof or to implement functionality similar to the indexers 236 and searchheads 226, respectively. In addition, the search head 504 describedherein may be utilized in place of or to implement functionality similarto the daemon 232 and the master 234 described with respect to FIG. 25of the Incorporated Applications. The intake system 210 described hereinmay be utilized in place of or to implement ingestion functionalitysimilar to the ingestion functionality of the worker nodes 214 of theIncorporated Applications. Similarly, the search nodes 506 describedherein may be utilized in place of or to implement search functionalitysimilar to the search functionality of the worker nodes 234 of theIncorporated Applications.

With reference to FIG. 27 of the Incorporated Applications, the indexingnodes 404 or search nodes 506 described herein may be utilized in placeof or to implement functionality similar to the index cache components254. For example, the indexing nodes 404 may be utilized in place of orto implement parsing, indexing, storing functionality of the index cachecomponents 254, and the search nodes 506 described herein may beutilized in place of or to implement searching or caching functionalitysimilar to the index cache components 254. In addition, the search head504 described herein may be utilized in place of or to implementfunctionality similar to the search heads 244, daemon 252, and/or themaster 250 described with respect to FIG. 27 of the IncorporatedApplications. The intake system 210 described herein may be utilized inplace of or to implement ingestion functionality similar to theingestion functionality of the worker nodes 246 described with respectto FIG. 27 of the Incorporated Applications. Similarly, the search nodes506 described herein may be utilized in place of or to implement searchfunctionality similar to the search functionality of the worker nodes234 described with respect to FIG. 27 of the Incorporated Applications.In addition, the common storage 216 described herein may be utilized inplace of or to implement functionality similar to the functionality ofthe cloud storage 256 and/or global index 258 described with respect toFIG. 27 of the Incorporated Applications.

With respect to the architectures of FIGS. 33, 46, and 48 of theIncorporated Applications, the intake system 210 described herein may beutilized in place of or to implement functionality similar to theforwarders 204. In addition, the indexing nodes 404 of the presentdisclosure can perform the functions described as being performed by theindexers 206 (e.g., parsing, indexing, storing, and in some embodiments,searching) of the architectures of FIGS. 33, 46, and 48 of theIncorporated Applications; the operations of the acceleration data store3308 of the architectures of FIGS. 33, 46, and 48 of the IncorporatedApplications can be performed by the acceleration data store 222 of thepresent application; and the operations of the search head 210, searchprocess maser 3302, and query coordinator 3304 of the architectures ofFIGS. 33, 46, and 48 of the Incorporated Applications can be performedby the search head 504, resource catalog 510, and or resource monitor508 of the present application. For example, the functionality of theworkload catalog 3312 and node monitor 3314 of the architectures ofFIGS. 33, 46, and 48 of the Incorporated Applications can be performedby the resource catalog 510 and resource monitor 508; the functionalityof the search head 210 and other components of the search process master3302 of the architectures of FIGS. 33, 46, and 48 of the IncorporatedApplications can be performed by the search head 504 or search master512; and the functionality of the query coordinator 3304 of thearchitectures of FIGS. 33, 46, and 48 of the Incorporated Applicationscan be performed by the search manager 514.

In addition, in some embodiments, the searching operations described asbeing performed by the worker nodes 3306 of the architectures of FIGS.33, 46, and 48 of the Incorporated Applications can be performed by thesearch nodes 506 of the present application and the intake or ingestionoperations performed by the worker nodes 3306 of the architectures ofFIGS. 33, 46, and 48 of the Incorporated Applications can be performedby the intake system 210. However, it will be understood that in someembodiments, the search nodes 506 can perform the intake and searchoperations described in the Incorporated Applications as being performedby the worker nodes 3306. Furthermore, the cache manager 516 canimplement one or more of the caching operations described in theIncorporated Applications with reference to the architectures of FIGS.33, 46, and 48 of the Incorporated Applications.

With respect to FIGS. 46 and 48 of the Incorporated Applications, thecommon storage 216 of the present application can be used to provide thefunctionality with respect to the common storage 2602 of thearchitecture of FIGS. 46 and 48 of the Incorporated Applications. Withrespect to the architecture of FIG. 48 of the Incorporated Applications,the intake system 210 described herein may be utilized in place of or toimplement operations similar to the forwarders 204 and ingested databuffer 4802, and may in some instances implement all or a portion of theoperations described in that reference with respect to worker nodes3306. Thus, the architecture of the present disclosure, or componentsthereof, may be implemented independently from or incorporated withinarchitectures of the prior disclosures.

5.0. IT and Security Operations Application Overview

As indicated above, the management of modern IT environments ofteninvolves managing a large number of devices and software componentsoperating within such environments. A system administrator of even amodestly sized IT environment might be responsible for the operation andsecurity of numerous servers, endpoint devices, firewalls, and varioustypes of software products and services running on those devices.Systems such as the SPLUNK® ENTERPRISE system, as well as various otherSIEM, security, and IT operations applications, provide ways toorganize, analyze, diagnose, and provide intelligence related to theoperation of components in users' IT environments.

The management of IT environments often further includes responding tovarious types of incidents that occur over time and which may beidentified from various analyses of the data generated by IT componentsin those environments, as described above. Such incidents can includesecurity-related incidents (such as viruses, network-based attacks,etc.), IT operations-related incidents (for example, hardware failures,software bugs, etc.), or any other events that potentially impact theoperation of an IT environment. Occurrences of such incidents can beflagged by the systems detecting the incidents and incident-relatedinformation may be provided to an administrator or other user foranalysis and remediation. Once a possible solution to an incident isidentified, the process for remediating such incidents can involveinteracting with one or several assets within the IT environment. Forexample, in response to identifying a security-related issue involvingan endpoint device, a system administrator might use security softwareto quarantine the endpoint device, interact with a firewall to updatenetwork settings, among other possible actions.

The ability for security analysts to readily respond to these types ofincidents and others in an IT environment can be aided by use of an ITand security operations platform or application, sometimes also referredto as an orchestration, automation, and response (OAR) platform orapplication, such as provided by the SPLUNK PHANTOM™ application. An ITand security operations application enables users to connect disparatecollections of computing devices and applications in IT environments andto automate tasks typically performed manually by system administratorsand other users in response to identifying various types of IT- andsecurity-related incidents.

FIG. 16 is a block diagram illustrating an example networked computingenvironment including an IT and security operations applicationaccording to some embodiments. In some embodiments, an IT and securityoperations application 1602 comprises software components executed byone or more electronic computing devices. In some embodiments, thecomputing devices are provided by a cloud provider network 1604. Inother embodiments, the IT and security operations application 1602operates on computing devices are managed within an on-premisesdatacenter or other computing environment, or on computing deviceslocated within a combination of cloud-based and on-premises computingenvironments.

The IT and security operations application 1602 generally enables usersto perform security orchestration, automation, and response operationsinvolving components of an organization's computing infrastructure.Among other benefits, an IT and security operations application 1602enables security teams and other users to automate repetitive tasks, toefficiently respond to security incidents and other operational issues,and to coordinate complex workflows across security teams and diverse ITenvironments. For example, users associated with various IT operationsor security teams (sometimes referred to herein generally as “analysts,”such as the example analyst teams 1606A and 1606B) can use variousclient devices 204 to interact with the IT and security operationsapplication 1602 via one or more networks 208 to perform operationsrelative to IT environments for which they are responsible (such as, forexample, tenant networks 1610A-1610N). Although only two security teamsare depicted in the example of FIG. 16, in general, any number ofseparate security teams can concurrently use the IT and securityoperations application 1602 to manage any number of respective tenantnetworks.

In some embodiments, users can interact with an IT and securityoperations application 1602 and data intake and query system 108 usingclient devices 204. The client devices 204 may communicate with the ITand security operations application 1602, and data intake and querysystem 108, in a variety of ways such as, for example, over an internetprotocol via a web browser or other application, via a command lineinterface, via a software developer kit (SDK), and so forth. In someembodiments, the client devices 204 can use one or more executableapplications or programs from the application environment 205 tointerface with the data intake and query system 108, such as the IT andsecurity operations application 1602. As mentioned, the applicationenvironment 205 include tools, software modules (for example, computerexecutable instructions to perform a particular function), and the like,that enable application developers to create computer executableapplications to interface with the data intake and query system 108. TheIT and security operations application 1602, for example, uses theapplication environment 205 to interface with the data intake and querysystem 108 to obtain relevant data, process the data, and display it ina manner relevant to the IT operations context. As shown, the IT andsecurity operations application 1602 further includes additional backendservices, middleware logic, front-end user interfaces, data stores, andother computing resources, and provides other facilities for ingestinguse case specific data and interacting with that data.

As an example of using the application environment 205, the IT andsecurity operations application 1602 includes various custom web-basedinterfaces (e.g., provided by a front end service 1608) that may or maynot leverage one or more UI components provided by the applicationenvironment 205. In this context, “mission control” refers to any typeof interface or set of interfaces that enable users broadly to obtaininformation about their IT environments, configure automated actions,playbooks, etc., and perform other operations related to IT and securityinfrastructure management. The IT and security operations application1602 may further include middleware business logic (including, forexample, an incident management service 1628, a threat intelligenceservice 1630, an artifact service 1632, a file storage service 1634, andan orchestration, automation, and response (OAR) service 1616)implemented on a middleware platform of the developer's choice.Furthermore, in some embodiments, an IT and security operationsapplication 1602 is instantiated and executed in a different isolatedexecution environment relative to the data intake and query system 108.As a non-limiting example, in embodiments where the data intake andquery system 108 is implemented in a Kubernetes cluster, the IT andsecurity operations application 1602 may execute in a differentKubernetes cluster (or other isolated execution environment system) andinteract with the data intake and query system 108 via the gateway 215.

In some embodiments, where an IT and security operations application1602 is deployed in a tenant network, the application can instead bedeployed as a virtual appliance at one or more computing devices managedby an organization using the IT and security operations application1602. A virtual appliance, for example, may comprise a VM image filethat is pre-configured to run on a hypervisor or directly on thehardware of a computing device and that includes a pre-configuredoperating system upon which the IT and security operations application1602 executes. In other embodiments, the IT and security operationsapplication 1602 can be provided and installed using other types ofstandalone software installation packages or software package managementsystems. Depending on the implementation and user preference, an IT andsecurity operations application 1602 optionally can be configured on astandalone server or in a clustered configuration across multipleseparate computing devices.

In some embodiments, a user initially configures an IT and securityoperations application 1602 using a web console or other interfaceprovided by the IT and security operations application 1602 (forexample, as provided by a front end service 1608 of the IT and securityoperations application 1602). For example, users can use a web browseror other application to navigate to the IP address or hostnameassociated with the IT and security operations application 1602 toaccess console interfaces, dashboards, and other interfaces used tointeract with various aspects of the application. The initialconfiguration can include creating and configuring user accounts,configuring connection settings to one or more tenant networks (forexample, including settings associated with one or more on-premisesproxies 1612A-1612N used to establish connections between on-premisesnetworks and the IT and security operations application 1602 running ina provider network 1604 or elsewhere), and performing other optionalconfigurations.

In some embodiments, a user (also referred to herein as a “customer” or“tenant”) of an IT and security operations application 1602 can createone or more user accounts to be used by a security team and other usersassociated with the tenant. A tenant of the IT and security operationsapplication 1602 typically desires to use the application to manage oneor more tenant networks for which the tenant is responsible (illustratedby example tenant networks 1610A-1610N in FIG. 16). A tenant networkincludes any number of IT assets 1614 operating as part of a corporatenetwork or other networked computing environment with which a tenant isassociated. Although the tenant networks 1610A-1610N are shown asseparate from the provider network 1604 in FIG. 16, more generally, atenant network can include components hosted in an on-premises network,in the provider network 1604, or combinations of both (for example,hybrid cloud networks).

In an embodiment, each of the IT assets 1614 in a tenant network canpotentially serve as a source of incident data to an IT and securityoperations application 1602, an asset against which actions can beperformed by the IT and security operations application 1602, or both.The IT assets 1614 can include various types of computing devices,software applications, and services including, but not limited to, adata intake and query system (which itself can ingest and processmachine data generated by other IT assets 1614), a SIEM system, a RESTclient that obtains and/or generates incident data based on the activityof other IT assets 1614, software applications (including operatingsystems, databases, web servers, etc.), routers, intrusion detectionsystems and intrusion prevention systems (IDS/IDP), client devices (forexample, servers, desktop computers, laptops, tablets, etc.), firewalls,and switches. The IT assets 1614 may execute upon any number separatecomputing device(s) and systems within a tenant network.

During operation, data intake and query systems, SIEM systems, RESTclients, and other system components of a tenant network may obtainoperational, performance, and security data from IT assets 1614 in thenetwork, analyze the data, and optionally identify potential IT-relatedincidents. A data intake and query system in a tenant network, forexample, may identify potential IT-related incidents based on theexecution of one or more correlation searches against data ingested andindexed by the system, as described elsewhere herein. Other data sources1644 may obtain incident-related data using other processes. Onceobtained, data indicating such incidents is sent to the data intake andquery system 108 or IT and security operations application 1602 via anon-premises proxy 1612N. For example, once a data intake and querysystem identifies a possible security threat or other IT-relatedincident based on data ingested by the data intake and query system,data representing the incident can be sent to the data intake and querysystem 108 via a REST API endpoint implemented by a gateway 215 or asimilar gateway of the IT and security operations application 1602. Asmentioned elsewhere herein, a data intake and query system 108 or IT andsecurity operations application 1602 may ingest, index, and store datareceived from each tenant network in association with a correspondingtenant identifier such that each tenant's data is segregated from othertenant data (for example, when stored in common storage 216 of the dataintake and query system 108 and a multi-tenant database 1636 of the ITand security operations application 1602).

As mentioned, in some embodiments, some or all of the data ingested andcreated by an IT and security operations application 1602 in associationwith a particular tenant is generally maintained separately from othertenants (for example, as illustrated by tenant data 1638-1638N in themulti-tenant database 1636). In some embodiments, a tenant may furtherdesire to keep data associated with two or more separate tenant networkssegregated from one another. For example, a security team associatedwith a managed security service provider (MSSP) may be responsible formanaging any number of separate tenant networks for various customers ofthe MSSP. As another example, a tenant corresponding to a businessorganization having large, separate departments or divisions may desireto logically isolate the data associated with each division. In suchinstances, a tenant can configure separate “departments” in the IT andsecurity operations application 1602, where each department isassociated with a respective tenant network or other defined collectionof data sources, IT assets, and so forth. Users and user teams can thususe this feature to manage multiple third-party entities ororganizations using only a single login and permissions configurationfor the IT and security operations application 1602.

In some embodiments, once an IT and security operations application 1602obtains incident data, either directly from a tenant network orindirectly via a data intake and query system 108, the IT and securityoperations application 1602 analyzes the incident data and enables usersto investigate, determine possible remediation actions, and performother operations. These actions can include default actions initiatedand performed within a tenant network without direct interaction fromuser and can further include suggested actions provided to usersassociated with the relevant tenant networks. Once the suggested actionsare determined, for example, these actions can be presented in a“mission control” dashboard or other interface accessible to users ofthe IT and security operations application 1602. Based on the suggestedactions, a user can select one or more particular actions to beperformed and the IT and security operations application 1602 can carryout the selected actions within the corresponding tenant network. In theexample of FIG. 16, an orchestration, automation, and response (OAR)service 1616 of the IT and security operations application 1602, whichincludes an action manager 1618, can cause actions to be performed in atenant network by sending action requests via network 206 to anon-premises proxy 1612A, which further interfaces with an on-premisesaction broker (for example, on-premises action broker 1620 in tenantnetwork 1610A). In this example, the on-premises action broker 1620 isimplemented to receive action requests from an action manager 1618 andto carry out requested actions against IT assets 1614 using connectors1622 and optionally a password vault 1624.

In some embodiments, to execute actions against IT assets in tenantnetworks and elsewhere, an IT and security operations application 1602uses a unified security language that includes commands usable across avariety of hardware and software products, applications, and services.To execute a command specified using the unified language, in someembodiments, the IT and security operations application 1602 (via anon-premises action broker 1620) uses one or more connectors 1622 totranslate the commands into the one or more processes or languagesnecessary to implement the action at one or more particular IT assets1614. For example, a user might provide input requesting the IT andsecurity operations application 1602 to remove an identified maliciousprocess from multiple computing systems in the tenant network 1610A,where two or more of the computing systems are associated with differentsoftware configurations (for example, different operation systems oroperating system versions). Accordingly, in some embodiments, the IT andsecurity operations application 1602 can send an action request to anon-premises broker 1620, which then uses one or more connectors 1622 totranslate the command into the necessary processes to remove eachinstance of the malicious process on the varying computing systemswithin the tenant network (including possible use of credentials andother information stored in the password vault 1624).

In some embodiments, an IT and security operations application 1602includes a playbooks manager 1626 that enables users to automate actionsor series of actions by creating digital “playbooks” that can beexecuted by the IT and security operations application 1602. At a highlevel, a playbook is a customizable computer program that can beexecuted by an IT and security operations application 1602 to automate awide variety of possible operations related to an IT environment. Theseoperations—such as quarantining devices, modifying firewall settings,restarting servers, and so forth—are typically performed by varioussecurity products by abstracting product capabilities using anintegrated “app model.” Additional details related to operation of theIT and security operations application 1602 and use of digital playbooksare provided elsewhere herein.

As mentioned, an IT and security operations application 1602 may beimplemented as a collection of interworking services that carry outvarious functionality described herein. In the example shown in FIG. 16,the IT and security operations application 1602 includes an incidentmanagement service 1628, a front end service 1608, an artifact service1632, a threat intelligence service 1630, a file storage service 1634,and an orchestration, automation, and response (OAR) service 1616. Theset of services comprising the IT and security operations application1602 in FIG. 16 are provided for illustrative purposes only; in otherembodiments, an IT and security operations application 1602 can becomprised of more or fewer services and each service may implement oneor more of the services shown.

In some embodiments, an incident management service 1628 is responsiblefor obtaining incidents or events (sometimes also referred to as“notables”), either directly from various data sources in tenantnetworks or directly based on data ingested by the data intake and querysystem 108 via the gateway 215. In some embodiments, the front endservice 1608 provides user interfaces to users of the application, amongother processes described herein. Using these user interfaces, users ofthe IT and security operations application 1602 can perform variousapplication-related operations, view displays of incident-relatedinformation, and can configure administrative settings, licensemanagement, content management settings, and so forth. In someembodiments, an artifact service 1632 manages artifacts associated withincidents received by the application, where incident artifacts caninclude information such as IP addresses, usernames, file hashes, and soforth. In some embodiments, a threat intelligence service 1630 obtainsdata from external or internal sources to enable other services toperform various incident data enrichment operations. As one non-limitingexample, if an incident is associated with a file hash, a threatintelligence service 1630 can be used to correlate the file hash withexternal threat feeds to determine whether the file hash has beenidentified as malicious. In some embodiments, a file storage service1634 enables other services to store incident-related files, such asemail attachments, files, and so forth. In some embodiments, an OARservice 1616 performs a wide range of OAR capabilities such as actionexecution (via an action manager 1618), playbook execution (via aplaybooks manager 1626), scheduling work to be performed (via ascheduler 1640), user approvals and so forth as workflows (via aworkflows manager 1642), and other functionality and described herein.

5.1. Data Intake

The operation of an IT and security operations application 1602generally begins with the ingestion of data related to various types ofincidents involving IT assets of various tenant networks (for example,IT assets 1614 of tenant network 1610A). In some embodiments, usersconfigure an IT and security operations application 1602 to obtain, or“ingest,” data from one or more defined data sources 1644, where suchdata sources can be any type of computing device, application, orservice that supplies information that users may want to store or actupon, where such data sources may include one or more of the IT assets1614 or data sources which generate data based on the activity of one ormore IT assets 1614. As mentioned, examples of data sources include, butare not limited to, a data intake and query system such as the SPLUNK®ENTERPRISE system, a SIEM system, a REST client, applications, routers,intrusion detection systems (IDS)/intrusion prevention systems (IDP)systems, client devices, firewalls, switches, or any other source ofdata identifying potential incidents in tenants' IT environments. Someof these data sources may themselves collect and process data fromvarious other data generating components such as, for example, webservers, application servers, databases, firewalls, routers, operatingsystems, and software applications that execute on computer systems,mobile devices, sensors, Internet of Things (IoT) devices, etc. The datagenerated by the various data sources can be represented in any of avariety of data formats.

In some embodiments, data can be sent from tenant networks to an IT andsecurity operations application 1602 using any of several differentmechanisms. As one example, data can be sent to data intake and querysystem 108, processed by the intake system 210, and obtained by anincident management service 1628 of the IT and security operationsapplication 1602. As another example, data can be sent from a tenantnetwork directly to the incident management service 1628, for example,via a REST endpoint.

In some embodiments, data ingested by an IT and security operationsapplication 1602 from configured data sources is represented in the ITand security operations application 1602 by data structures referred toas “incidents, “events,” “notables,” or “containers”. Here, an incidentor event is a structured data representation of data ingested from adata source and that can be used throughout the IT and securityoperations application 1602. In some embodiments, an IT and securityoperations application 1602 can be configured to create and recognizedifferent types of incidents depending on the corresponding type of dataingested, such as “IT incidents” for IT operations-related incidents,“security incidents” for security-related incidents, and so forth. Anincident can further include any number of events and “artifacts,” whereeach event and artifact represents an item of data associated with theincident. As a non-limiting example, an incident used to represent dataingested from an anti-virus service and representing a security-relatedincident might include an event indicating the occurrence of theincident and associated artifacts indicating a name of the virus, a hashvalue of a file associated with the virus, a file path on the infectedendpoint, and so forth.

In some embodiments, each incident of an IT and security operationsapplication 1602 can be associated with a “status” or “state” thatchanges over time. This status information can be used by analysts, forexample, to indicate to other analysts what incidents are being workedupon, what incidents have been closed or resolved, what incidents areawaiting input or action, and the like. Furthermore, the transitions ofincidents from one status to another can be used to generate variousmetrics related to analyst efficiency and other measurements of analystteams. For example, the IT and security operations application 1602 maybe configured with a number of default statuses, such as “new” or“unknown” to indicate incidents that have not yet been analyzed, “inprogress” for incidents that have been assigned to an analyst and areunder investigation, “pending” for incidents that are waiting input oraction from an analyst, and “resolved” for incidents that have beenaddressed by an assigned analyst. An amount of time that elapses betweenthese statuses can be used to calculate various measures of analyst andanalyst team efficiency, such as measurements of a mean time to resolveincidents, a mean time to respond to incidents, a mean time to detect anincident that is a “true positive,” a mean dwell time reflecting anamount of time taken to identify and remove threats from an ITenvironment, among other possible measures. Analyst teams may alsocreate custom statuses to indicate incident states that may be morespecific to the way the particular analyst team operates, and furthercreate custom efficiency measurements based on such custom statuses.

In some embodiments, the IT and security operations application 1602also generates and stores data related to its operation and activityconducted by various tenant users including, for example, playbook data,workbook data, user account settings, configuration data, and historicaldata (such as, for example, data indicating actions taken by varioususers relative to particular incidents or artifacts, data indicatingresponses from IT assets based on action executions, and so forth), inone or more multi-tenant databases 1636. In other embodiments, some orall of the data above is stored in storage managed by the data intakeand query system 108 and accessed via the gateway 215. Thesemulti-tenant database(s) 1636 may operate on a same computer system asthe IT and security operations application 1602 or at one or moreseparate database instances. As mentioned, in some embodiments, thestorage of such data by the data intake and query system 108 and IT andsecurity operations application 1602 for each tenant is generallysegregated from data associated with other tenants on the basis oftenant identifiers stored with the data and other access controlmechanisms.

5.2. Actions

In some embodiments, an IT and security operations application 1602defines many different types of “actions,” which are high-level, vendor-and product-agnostic primitives that can be used throughout the IT andsecurity operations application 1602. Actions generally represent simpleand user-friendly verbs that are used to execute actions in playbooksand manually through other user interfaces of the IT and securityoperations application 1602, where such actions are performed againstone or more assets in an IT environment. In many cases, a same actiondefined by the IT and security operations application 1602 can becarried out on assets associated with different vendors orconfigurations via action translation processes performed by various“connectors” of the platform, as described in more detail elsewhereherein. Examples of actions that may be defined by an IT and securityoperations application 1602 include a “get process dump” action, a“block IP address” action, a “suspend VM” action, a “terminate process”action, and so forth.

5.3. Connectors

In an embodiment, an IT and security operations application 1602 enablesconnectivity with various IT assets in a provider network 1604 and intenant networks 1610A-1610N, including IT assets from a wide variety ofthird-party IT and security technologies, and further enables theability to execute actions against those assets via “connectors” (suchas the connectors 1622 in tenant network 1610A and connectorsimplemented as part of the IT and security operations application 1602).In general, a connector 1622 represents program code that provides anabstraction layer (for example, via a library, API, or other interface)to one or more of hundreds of possible IT and security-related productsand services and which exposes lists of actions supported by thoseproducts and services. Each connector 1622 may also define which typesof assets that the connector can operate on.

As one example, an IT and security operations application 1602 may beconfigured with a connector 1622 that enables the application tocommunicate with a VM product provided by a third-party vendor. In thisexample, the connector for the VM product enables the IT and securityoperations application 1602 to take actions relative to VM instanceswithin a user's IT environment, including starting and stopping the VMs,taking VM snapshots, analyzing snapshots, and so forth. In order for theconnector to communicate with individual instances, the connector 1622can be configured with login credentials, hostname or IP address, and soforth, for each instance with which communication is desired (orconfigured to obtain such information from a password vault 1624). Otherconnectors 1622 may be available for VM products from other third-partyvendors, where those connectors are configured to translate some or allof the same actions that are available with respect to the first type ofVM product. In general, connectors 1622 enable interaction withvirtually any type of IT asset 1614 in an IT environment and can beadded and updated over time to support new types of assets.

5.4. Assets

In an embodiment, IT assets 1614 are instances of physical or virtualcomponents within an organization with which an IT and securityoperations application 1602 communicates (for example, via connectors asdescribed above). Examples of IT assets 1614 include, but are notlimited to, servers, endpoint devices, routers, and firewalls. An ITasset 1614 is represented in an IT and security operations application1602 by data identifying the asset, including information used tocommunicate with the device or service such as, for example, an IPaddress, automation service account, username, password, and so forth.In an embodiment, one or more IT assets 1614 can be configured as asource of incident information that is ingested by an IT and securityoperations application 1602. The types of IT assets 1614 that can beconfigured in the IT and security operations application 1602 may bedetermined in some cases based on which connectors 1622 are installed.In some embodiments, automated actions can be configured with respect tovarious IT assets 1614 using playbooks, described in more detailelsewhere herein. Each IT asset 1614 may be hosted in an on-premisestenant network, a cloud-based provider network, or any other network orcombination thereof.

5.5. Playbooks

In some embodiments, the operation of an IT and security operationsapplication 1602 includes the ability to create and execute customizableplaybooks. At a high level, a playbook comprises computer program codeand possibly other data that can be executed by an IT and securityoperations application 1602 to carry out an automated set of actions(for example, as managed by a playbooks manager 1626 as part of the OARservice 1616). In one embodiment, a playbook is comprised of one or morefunctions, or codeblocks, where each codeblock contains program codethat performs defined functionality when the codeblock is encounteredduring execution of the playbook of which it is a part. As an example, afirst codeblock of a playbook might implement an action that uponexecution affects one or more IT assets 1614 (e.g., by configuring anetwork setting, restarting a server, etc.), another codeblock mightfilter data generated by the first codeblock in some manner, yet anothercodeblock might obtain information from an external service, and soforth. A playbook is further associated with a control flow that definesan order in which the codeblocks of the playbook are executed, where acontrol flow may vary at each execution depending on particular inputconditions (e.g., where the input conditions may derive from attributesassociated with an incident triggering execution of the playbook, orbased on.

The IT and security operations application 1602 described hereinprovides a visual playbook editor (for example, as an interface providedby a front end service 1608) that allows users to visually create andmodify playbooks. Using a visual playbook editor GUI, for example, userscan codify a playbook by creating and manipulating a displayed graphincluding nodes and edges, where each of the nodes in the graphrepresents a codeblock that performs one or more defined operationsduring execution of the playbook, and where the edges represent thecontrol flow among the playbook's codeblocks. In this manner, users cancraft playbooks that perform complex sequences of operations withouthaving to write some or any of the underlying code. The visual playbookeditor interfaces further enable users to supplement or modify theautomatically generated code by editing the code associated with avisually designed playbook, as desired.

5.5.1. Playbooks Management

In an embodiment, an IT and security operations application 1602provides one or more playbook management interfaces that enable users tolocate and organize playbooks associated with a user's account. Aplaybook management interface can display a list of playbooks that areassociated with a user's account and further provide information abouteach playbook such as, for example, a name of the playbook, adescription of the playbook's operation, a number of times the playbookhas been executed, a last time the playbook was executed, a last timethe playbook was updated, tags or labels associated with the playbook, arepository at which the playbook and the associated program code isstored, a status of the playbook, and the like.

FIG. 17 illustrates an example playbook management interface accordingto some embodiments. The playbook management interface 1700 shown inFIG. 17 includes a playbook list 1702. As indicated above, a playbooklist 1702 includes several columns indicating information about eachplaybook including, for example, a name of the playbook, one or morelabels associated with each playbook, a repository at which the playbookis stored, a category associated with each playbook, and a status of theplaybook. In an embodiment, a user can also use interface elements 1704to sort the displayed list of playbooks, to refresh the playbook list,to export and download a copy of one or more playbooks (e.g., includingthe program code associated with the playbook and other playbookmetadata), and to create a new playbook, among other possibleoperations. In an embodiment, a user can also provide input selecting aplaybook to view in the visual playbook editor so that the user canmodify the selected playbook, if desired. The modification of a playbookusing a visual playbook editor is described further hereinafter.

5.5.2. Playbook Creation and Configuration

In an embodiment, users can create a new digital playbook starting froma playbook management interface, as described in reference to FIG. 17,or using another interface provided by the IT and security operationsapplication 1602. Using the playbook management interface 1700, forexample, a user can select the “create new playbook” interface elementfrom interface elements 1704. Once a user has provided input requestingthe creation of a new playbook, the IT and security operationsapplication 1602 displays a visual playbook editor interface including agraphical canvas on which users can add nodes representing operations tobe performed during execution of the playbook, where the operations areimplemented by associated source code that can be automaticallygenerated by the visual playbook editor, and connections or edges amongthe nodes defining an order in which the represented operations areperformed upon execution.

FIG. 18 illustrates a visual playbook editor canvas that can be used tovisually design a playbook. As illustrated in FIG. 18, a visual playbookeditor interface 1800 includes a playbook canvas 1802 initiallyincluding two nodes corresponding to a start block 1804 and an end block1806, respectively, where those nodes represent a start and end pointfor execution of the playbook being designed. In the illustratedexample, the visual playbook editor interface 1800 further displays anexample dialog box 1808 instructing a user to select the start block1804 and to create an edge or connection originating from the startblock 1804 to add a new block to the playbook. As described in moredetail below, the visual playbook editor interface 1800 enables users toadd various types of blocks to a playbook including, for example,playbook blocks, decision blocks, filter blocks, action blocks, formatblocks, prompt blocks, task blocks, and API blocks.

In an embodiment, one type of block that can be added to a playbook isan action block. Once an action block is added to a playbook, the visualplaybook editor interface can guide the user in selecting an action tobe performed when the action block is encountered during execution ofthe playbook. A user can optionally further configure an action blockusing various items of data accessible to the action block including,for example, data stored as part of an incident and associated eventsand artifacts as well as other output variables generated by otherplaybook blocks. For example, if a user adds an action block thatperforms the operation of geolocating an IP address, a user mayconfigure the action block to use an IP address corresponding to aselected artifact of an incident that initiated the playbook's executionor based on an IP address obtained by an upstream block using otherprocesses.

In an embodiment, another type of block that a user can add to aplaybook is a prompt block. A prompt block is generally used to add userinteraction to a playbook by causing information to be requested fromone or more users at a particular point during execution of theplaybook. The information requested and provided by a user can be usedby other downstream blocks of the playbook. For example, a playbookmight include an action block that detects the presence of potentiallymalicious IP addresses, further include a serially-connected promptblock that presents information to a user about the detected potentiallymalicious IP address and requests a yes/no response from the userindicating whether the IP address should be blocked, followed by anotherserially-connected action block that either blocks the IP address at afirewall or not depending on the input received from a user in responseto the prompt block.

In some embodiments, a prompt block is associated with variousproperties that can be configured by a user using a visual playbookeditor including, for example, configurations indicating a promptapprover, a required response time, a message prompt, and a responsetype. The assignment of a prompt approver indicates an individual useror user role (e.g., administrator, engineer, manager) that is to receivethe prompt to be acted upon during execution of the correspondingplaybook. A required response time indicates an amount of time that anassigned approver or set of approvers have to complete the prompt, forexample, by accessing the prompt and providing any requested informationor otherwise performing actions specified by the prompt. A messageprompt is information that is displayed to a user when the user accessesan assigned prompt (for example, a message prompt can be presented aspart of a GUI interface element displayed to a user accessing anassigned prompt). A response type indicates a type of acceptableresponse that can be provided by a user to successfully complete theprompt (for example, a yes/no response, a numerical value response, atext-based response, or a response from an enumerated list of options).

In some embodiments, a user accesses a prompt that has been generatedfor the user during execution of a playbook via a notification presentedin a “mission control” or other type of interface of the IT and securityoperations application 1602. In response to a user accessing an assignedprompt (for example, by providing input selecting a notificationindicating the existence of the prompt), the IT and security operationsapplication 1602 causes display of an interface element that includes amessage indicating what information is being requested from the user. Auser assigned a prompt can either complete the prompt (that is, accessthe prompt and provide any requested data), delegate the prompt to adifferent user, or allow the deadline for responding to the prompt totime out. A prompt is successfully completed when either the designateduser, or a user to whom the prompt is delegated, completes the prompt.If a prompt is assigned to a group of users, a prompt can besuccessfully completed when either at least one user of the groupcompletes the prompt, or when all users of the group complete theprompt, depending on how the prompt is configured.

In an embodiment, yet another type of function block that can be addedto a playbook is a task block. A task block is generally configured tosend a message to a user or group of users to be acknowledged by theusers. A task block can be further configured by specifying an approver(that is, a user or user role to whom the task is sent), a responsedeadline (for example, expressed in minutes from the time at which thetask is generated), a message to be displayed to the user(s), amongother possible configurations.

In an embodiment, yet another type of block that can be added toplaybooks in a visual playbook editor is a decision block. A decisionblock generally can be used to control program flow associated with theplaybook. For example, during execution of a playbook, a decision blockcan be used to determine whether the execution flow proceeds next to ablock A or to a block B (or block C, and so forth) depending on theoutcome of one or more logical conditions defined by the decision block.These logical conditions, for example, can be based on comparisonsinvolving artifact data, container properties, date functions, actionresults, among other possible types of input data. The use of a decisionblock in a playbook, for example, is conceptually similar to an if-thenconditional statement found in high-level programming languages.

In an embodiment, yet another type of block that can be included in aplaybook is an API block. An API block can be used, for example, to setvarious parameters associated with an incident container upon which theplaybook is executing or to interact with the IT and security operationsapplication 1602 in other ways supported by an associated API. Forexample, an API block can be used to set a severity level associatedwith an incident container, to indicate that the incident container isresolved, to associate a label with the incident container, add acomment to the container, among other possible operations.

In an embodiment, the creation of a graph representing a playbookincludes the creation of connections between function blocks, where theconnections are represented by edges that visually connect the nodes ofthe graph representing the collection of function blocks. Theseconnections among the playbook blocks indicate a program flow for theplaybook, defining an order in which the operations specified by theplaybook blocks are to occur. For example, if a user creates aconnection that links the output of a block A to the input of a block B,then block A executes to completion before execution of block B beginsduring execution of the playbook. In this manner, output variablesgenerated by the execution of block A can be used by block B (and anyother subsequently executed blocks) during playbook execution.

In an embodiment, users can create connections that link function blocksof a playbook in parallel. For example, a user can create a connectionthat links the output of a function block A to the input of a functionblock B and separately to the input of a function block C. In thisexample, the IT and security operations application 1602 can execute theoperations defined by function blocks B and C in parallel, although theexact ordering of the execution may not be guaranteed. For someplaybooks, the execution of two or more function blocks in parallel mayprovide a performance benefit compared to executing the function blocksserially.

In an embodiment, the visual representation of a playbook in a visualplaybook editor, comprising a collection of nodes and edges, can bemodified over time. Users can provide input via the visual playbookeditor interface, for example, to rearrange the location of andconnection between nodes in the graph and the visual playbook editor canroute existing connections among the nodes accordingly such that aneasily understandable visual representation is provided. In someembodiments, multiple nodes can be selected and moved around the canvasas a group.

5.5.3. Playbook Execution

Once a user has codified a playbook using a visual playbook editor orother interface, the playbook can be saved (for example, in amulti-tenant database 1636 and in association with one or more useraccounts) and run by the IT and security operations application 1602on-demand. As illustrated in the example playbooks above, a playbookincludes a “start” block that is associated with source code that beginsexecution of the playbook. More particularly, the IT and securityoperations application 1602 executes the function represented by thestart block for a playbook with container context comprising data aboutthe incident against which the playbook is executed, where the containercontext may be derived from input data from one or more configured datasources. A playbook can be executed manually in response to a userproviding input requesting execution of the playbook, or playbooks canbe executed automatically in response to the IT and security operationsapplication 1602 obtaining input events matching certain criteria. Inembodiments where the source code associated with a playbook is based onan interpreted programming language (for example, such as the Pythonprogramming language), the IT and security operations application 1602can execute the source code represented by the playbook using aninterpreter and without compiling the source code into compiled code. Inother examples, the source code associated with a playbook can first becompiled into byte code or machine code the execution of which can beinvoked by the IT and security operations application 1602.

5.5.4. Custom Code Blocks

As indicated above, each of the nodes of a playbook representsexecutable code that, upon execution, performs operations used toautomate various tasks that a user desires to have carried out. In someembodiments, an IT and security operations application provides a set ofpredefined codeblocks that perform common operations and furtherprovides ways for users to arrange the codeblocks in a manner thatenables a wide range of automations. However, there remain manyuser-specific use cases for which any arrangement of predefinedcodeblocks is insufficient. In these scenarios and others, it may bedesirable for users to create custom modifications or additions to thecode associated with a playbook. For example, a user may desire tomodify or supplement the operations that are performed by one or morepre-defined function blocks for particular use cases relevant to theuser. In some embodiments, a visual playbook editor enables users tomake such modifications to the source code associated with the functionblock of a playbook and further enables users to insert code into globalsections of a playbook's associated source code.

FIG. 22 illustrates an example visual playbook editor interface thatenables users to modify source code associated with a playbook. In theexample visual playbook editor interface 2200 shown in FIG. 22, a userhas provided input indicating a desire to edit the source codeassociated with the playbook graph 2202. In response to receiving suchinput, the visual playbook editor interface 2200 displays a code editorsection 2204 showing the source code associated with the displayedplaybook graph 2202 and that further enables a user to modify the sourcecode. Users can optionally cause display of the source code associatedwith an entire playbook (for example, by selecting the “Full Code” tab2206), or the source code associated with only one or more selectednodes in a playbook (for example, by selecting the “Function” tab 2208).The ability to view the full source code associated with a playbook, forexample, can enable users to edit a “global” section of the playbook.Modifications to a global section of a playbook's source code can beused, for example, to import additional code libraries and to implementother functionality that is not specific to a particular function blockof the playbook.

Once a user customizes source code associated with one or more playbookfunction blocks as described above, however, the visual playbook editoris not able determine the effects of the user's custom changes to thecode and may disable the user's ability to modify the affected blocksusing the visual playbook editor. For example, when the visual playbookeditor is used to configure a block without any custom code changes, thevisual playbook editor automatically generates the underlying sourcecode corresponding to the user's configurations made to the block viathe visual playbook editor. However, if a user has added custom code toa playbook block and were to then subsequently use the visual playbookeditor to make further changes, the visual playbook editor wouldoverwrite the user's custom code since it cannot be aware of how theuser's custom code integrates with the code the visual playbook editorautogenerates. Thus, once a user has added custom code to a block, thevisual playbook editor may disable the user's ability to further modifythe block via the interface to avoid such issues.

Furthermore, an existing visual playbook editor is generally unable toprovide a useful representation of custom code added to a playbook blockor to the global section of the playbook in a displayed playbook graph.For example, because the visual playbook editor is unable to determinethe exact nature of the user's custom code, the playbook editor isunable to visually represent the functionality of the custom code in aplaybook graph. Thus, users viewing a playbook in the visual playbookeditor are typically unable to visually understand how customfunctionality added to a playbook interacts with other functionalityrepresented by the portions of the playbook displayed in the visualplaybook editor.

According to embodiments described herein, to better facilitate theaddition of custom code to a playbook, a visual playbook editor enablesusers to add “custom code” function blocks to playbooks, where a customcode function block is associated with user-generated source code thatis part of a playbook. Once added to a playbook, a visual playbookeditor of an IT and security operations application 1602 displays a nodethat visually identifies custom code function blocks as part of aplaybook, and further enables users to create connections between customcode function blocks and other function blocks of a playbook. Theconnections between a custom code function block and other playbookblocks can be associated with input parameters and output variablesusable by the custom code function block and by other downstreamfunction blocks of a playbook. Among other benefits, custom codefunction blocks enable the full integration of users' custom code intothe visual representation of playbooks by a visual playbook editor,allowing users to readily understand the relationship of custom code toother parts of the playbook of which it is a part. Furthermore, thevisual representation of such custom code blocks enables users to easilyreuse the blocks within the same playbook or across different playbooks.

FIG. 23 illustrates an example of adding a custom code block to aplaybook using a visual playbook editor according to some embodiments.As shown in FIG. 23, a visual playbook editor interface 2300 includes aninitial playbook graph including a start block (not shown) and an endblock 2302. In this example, a user has created a connection 2304originating from the start block indicating a desire to add a functionblock to the playbook. Based on this input, the visual playbook editorinterface 2300 has displayed a function block selection panel 2306displaying various types of function blocks that can be added to thegraph such as, for example, an action block, a playbook block, an APIblock, a filter block, etc.

In an embodiment, the types of blocks that a user can add to a playbookin the visual playbook editor interface 2300 include a custom codefunction block, represented by the selectable custom code function blockicon 2308 in the function block selection panel 2306. In response touser selection of the icon 2308, a new custom code function block isadded to the playbook in the visual playbook editor interface 2300 andavailable for further modification as desired by the user. For example,a user can further specify one or more input parameters and outputvariables to be associated with the custom code function block, andfurther provide the user-generated source code to be associated with thecustom code function block, as described below.

FIG. 24 illustrates the configuration of a custom code function block ina visual playbook editor according to some embodiments. As shown, thevisual playbook editor interface 2400 includes a custom code functionblock 2402 which, for example, may have be added based on selection of acustom code function block from the selection panel 2306 in FIG. 23. Thevisual playbook editor interface 2400 further illustrates a custom codefunction block settings panel 2404. The custom code function blockconfiguration panel 2404 enables users to configure input parametersassociated with the selected custom code function block 2402 (forexample, using the interface elements 2406) and to specify one or moreoutput variables (for example, using the interface elements 2408), amongother possible configurations. FIG. 24 further illustrates a code editorpanel 2410 that enables users to modify the custom code associated withthe custom code function block 2402.

As indicated above, a custom code function block can be associated withuser-generated code, the output of which can be used by downstreamfunction blocks in a playbook. During execution of the playbook, forexample, one or more output variables associated with a custom codefunction block can be saved to global state associated with theplaybook's execution and can be used by other blocks by referring todefined names for the output variable(s). In some embodiments, thevisual playbook editor allows users to create a custom name for outputvariables associated with a custom code function block, where a customvariable name can be used by other function blocks to refer to theoutput variable.

FIG. 25 illustrates an example of a downstream block in a playbook usingan output variable generated by an upstream custom code function blockaccording to some embodiments. In the example of FIG. 25, using thevisual playbook editor interface 2500, a user has selected a formatblock 2502 that is downstream from a custom code function block and thatis using a configuration panel 2504 to configure settings associatedwith the format block 2502. In particular, the configuration panel 2504shows that a user is able to select an output variable generated by anupstream custom code function block(“custom_function_1:custom_function.output”) as a template parameter.Other types of function blocks can similarly use the visual playbookeditor to refer to output variables of a custom code function block asdesired, thereby enabling a custom code function block and itsattributes to be fully integrated into the visual representation of theplaybook.

FIG. 26 is a flow diagram illustrating operations 2600 of a method forproviding a visual playbook editor used to create playbooks for an ITand security operations application, the visual playbook editorincluding the ability to add custom code function blocks to a playbook,according to some embodiments. Some or all of the operations 2600 (orother processes described herein, or variations, and/or combinationsthereof) are performed under the control of one or more computer systemsconfigured with executable instructions and are implemented as code(e.g., executable instructions, one or more computer programs, or one ormore applications) executing collectively on one or more processors, byhardware or combinations thereof. The code is stored on acomputer-readable storage medium, for example, in the form of a computerprogram comprising instructions executable by one or more processors.The computer-readable storage medium is non-transitory. In someembodiments, one or more (or all) of the operations 2600 are performedby an IT and security operations application of the other figures.

The operations 2600 include, at block 2602, causing display of a GUIincluding a visual playbook editor for a playbook associated with an ITand security operations application, wherein the playbook is associatedwith computer program source code comprising a collection of relatedfunction blocks that define a series of operations to be performed inresponse to identification of an incident in an IT environment, andwherein the collection of related function blocks is represented by agraph displayed in a visual playbook editor. As illustrated in FIG. 22and other figures, a visual playbook editor interface 2200 can be usedto display a visual representation of a playbook including a collectionof related function blocks represented by a graph displayed in a visualplaybook editor.

The operations 2600 further include, at block 2604, receiving input viathe visual playbook editor, the input including: first input causingaddition to the graph of a node representing a custom code functionblock, the custom code function block associated with user-generatedsource code to be executed as part of execution of the playbook, secondinput specifying one or more output variables associated with the customcode function block, and third input creating a connection between thenode representing the custom code function block and at least one othernode of the graph representing the playbook. For example, as illustratedin the example of FIG. 23, a user can use a function block selectionpanel 2306 to cause addition to the graph of a node representing acustom code function block. As further illustrated in the example ofFIG. 24, a custom code function block configuration panel 2404 can beused to provide additional input specifying one or more output variablesassociated with the custom code function block, and the user can furtheruse the visual playbook editor interface 2400 to create connectionsbetween the node representing the custom code function block and othernodes of the graph representing the playbook.

In an embodiment, the operations further include determining that a userrequesting addition of the custom code function block has sufficientpermissions to add custom code to the playbook. For example, a visualplaybook editor may be associated with user permissions that determinewhat types of operations certain users can perform on playbooks. In somecases, it may be desirable to limit some or all users' ability to addcustom code to a playbook, for example, to enable simpler auditing ofplaybook functionality. In this example, a playbook editor can determinewhether a user has sufficient permissions to add custom code to theplaybook under development before enabling a custom code function blockto be added to the playbook.

In an embodiment, the second input further includes one or more inputparameters, and wherein at least one of the one or more input parametersis associated with a value generated by another function block of theplaybook. Referring to FIG. 24, for example, a custom code functionblock configuration panel 2404 enables users to specify one or moreinput parameters for the custom code function block, where the inputparameters can be supplied by upstream blocks in the playbook and usedduring execution of the custom code function block.

In an embodiment, the input received via the visual playbook editorfurther includes fourth input specifying a custom variable name to beused to identify an output variable of the one or more output variables.Referring again to FIG. 24, for example, a user can use a custom codefunction block configuration panel 2404 to configure custom variablenames to identify output variables associated with a custom codefunction block. In an embodiment, the operations further includedetermining that a user requesting addition of the custom code functionblock has sufficient permissions to add custom code to the playbook.

In an embodiment, the third input defining the at least one connectionbetween the custom code function block at the at least one otherfunction block in the playbook includes input to the visual playbookeditor creating a graphical edge between a first graphicalrepresentation of the custom code function block and a second graphicalrepresentation of the at least one other function block. Referring againto FIG. 25, for example, a user can use the visual playbook editorinterface 2500 to create a connection between a created custom codefunction block (not shown in FIG. 25) and the format block 2502 bycreating a graphical edge between the blocks, illustrated by thedirected line connecting the blocks in the interface.

The operations 2600 further include, at block 2606, causing display ofthe node representing the custom code function block as part of thegraph displayed in the visual playbook editor. In an embodiment, thecustom code function block is displayed in the visual playbook editorusing a graphical representation that indicates that the custom codefunction block represents user-generated custom code. Referring to FIG.24, for example, the visual playbook editor interface 2400 displays thecustom code function block 2402 using a particular visual representationindicating that the block represents user-generated code (for example,as indicated by the icon and block title “Custom Function”), therebyenabling users to readily identify portions of the playbook that containcustom code.

In an embodiment, at least one of the one or more output variables isused by another function block of the playbook. As illustrated by theexample in FIG. 25, various types of downstream function blocks can beconfigured using a visual playbook editor and can refer directly tooutput variables generated by one or more upstream custom code functionblocks.

In an embodiment, the operations further include receiving additionalinput causing the visual playbook editor to create a copy of the customcode function block in the playbook. Referring to FIG. 24, for example,a user can select a custom code function block 2402 and provide inputrequesting to copy the function block such that the function block canbe “pasted” at a different location in the playbook graph. A user canthen optionally further configure the copied version of the functionblock as desired. In some embodiments, a user can create a copy of acustom code function block in a different playbook. In both cases, thecreation of a copy of a custom code function block includes creating acode of the underlying source code and any associated settings (forexample, defined input parameters and output variables).

In an embodiment, the user-generated source code includes a request thatuses an API provided by the IT and security operations application 1602.For example, a user can use a custom code editor to make API requests tomodify container context or perform other operations supported by an ITand security operations application 1602.

In an embodiment, the playbook is executed automatically in response tothe IT and security operations application 1602 obtaining timestampedevent data satisfying one or more criteria. For example, the IT andsecurity operations application 1602 may be configured to execute theplaybook based on timestamped event data obtained from a data sourcesuch as a data intake and query system 120.

In an embodiment, the operations further include causing display of atleast a portion of the user-generated source code in the visual playbookeditor. Referring to FIG. 24, for example, a visual playbook editorinterface 2400 can display a code editor panel 610, which a user can useto modify the source code represented by a displayed custom codefunction block. In an embodiment, changes to the source code made by auser using a code editor panel 610 can be saved as part of the customcode function block (or optionally reverted if the user desires to undothe most recent changes made). In an embodiment, execution of the customcode function block includes generating output displayed in a debuggerthat is displayed as part of the visual playbook editor. For example,the output displayed in the debugger can be used to diagnose issues witha user's custom source code created as part of a custom code functionblock.

5.6. Workbooks

Some IT and security operations applications 1602, such as the SPLUNKPHANTOM™ application, include the ability for users to create,customize, and use “workbooks.” At a high level, a workbook enablesusers to codify an organization's standard operating procedures (SOPs)and other defined processes for responding to incidents (for example,security threats, operational issues, etc.) within an IT environmentinto reusable templates. In some embodiments, a workbook is comprised ofone or more user-defined phases (for example, detection, analysis,containment, eradication, recovery, and so forth, in the context of asecurity investigation), where each phase includes one or moreuser-defined tasks to be performed by assigned analysts or other users.A workbook in this way defines an overall procedure that helps guideusers of an IT and security operations application through the processof responding to, documenting, and reporting incidents when they occur.Different workbook templates can be defined for responding to differenttypes of incidents—for example, one workbook template might be createdto help analysts investigate and respond to computer security incidents,while another workbook template can be created to help analysts recoverfrom and report significant hardware failures, and so forth. In someexamples, workbook templates can be created to help analysts carry outvarious industry-wide SOPs such as the NIST-800-61 standard forresponding to computer security incidents and others.

In some embodiments, each task defined as part of a workbook templatecan be optionally associated with one or more automated actions orplaybooks that can be executed by the IT and security operationsapplication 1602 to help to carry out the task. For example, if aworkbook includes a task of obtaining a particular log file at one ormore endpoint devices associated with an incident, that task can beassociated with an automated action or playbook for obtaining therelevant log files without additional manual user involvement. A usermay specify a set of one or more executable actions, playbooks, or acombination thereof, in association with some or all of a workbook'stasks as part of the workbook template configuration process. In someembodiments, the IT and security operations application 1602 canadditionally or alternatively automatically associate actions andplaybooks with particular tasks, for example, by matching tasks topossible actions/playbooks based on an analysis of the text or otherattributes associated with phase/task definitions.

In some embodiments, an IT and security operations application 1602includes various GUIs that enable users to interact with workbooks. Forexample, in response to the IT and security operations application 1602identifying an occurrence of a particular type of incident, the IT andsecurity operations application 1602 may instantiate a new workbookbased on a previously defined workbook template associated with thattype of incident (for example, if a malware attack is identified, the ITand security operations application 1602 can create a new workbook basedon a computer security incident workbook template). Once a new workbookis created, analysts can use these interfaces to complete assigned tasksand to view the workbook's progress. Users can perform assigned workbooktasks, for example, either by manually performing the tasks or byselecting one or more automated actions or playbooks associated with thetask. Icons or other graphical elements representing the automatedactions and playbooks associated with the various workbook tasks can begraphically displayed, for example, such that a user can executeassociated actions/playbooks simply by selecting a correspondinginterface element in a workbook GUI.

In some embodiments, an IT and security operations application 1602further optimizes the presentation of executable actions and playbooksdisplayed in connection with workbook tasks. For example, instead ofdisplaying the actions and playbooks associated with workbook tasks inan arbitrary order, the IT and security operations application 1602 canmonitor and log the efficacy of each action and playbook over time anduse such data to determine a prioritized order in which to display theactions/playbooks in a workbook (or determine whether to displayparticular actions or playbooks at all). For example, when an actionassociated with a task is executed, the IT and security operationsapplication 1602 can monitor the action's execution and determinewhether the action executed successfully (for example, if an action isconfigured to terminate a process running on an endpoint device, the ITand security operations application 1602 can determine whether theaction was actually able to successfully connect to the endpoint deviceand terminate the process). This information can be collected over timeand used, for example, to display actions/playbooks associated withvarious tasks in an order that reflects how successful eachaction/playbook historically has been in completing the task so thatanalysts can be guided to those actions/playbooks most likely tosuccessfully complete a task. In some embodiments, this data can becollected and analyzed on a per-tenant basis and, in some embodiments,collected and analyzed across some or all tenants of the IT and securityoperations application 1602.

As indicated above, an IT and security operations application 1602 mayinclude various GUIs that can be used to define workbook templates andto interact with workbook instances. FIG. 19 illustrates an exampleworkbook template configuration interface used to create a workbooktemplate according to some embodiments. As illustrated in FIG. 19, aworkbook template configuration interface 1900 includes interfaceelements for specifying information about a workbook template generally,and additional interface elements used to define the phases and tasksassociated with the workbook.

In some embodiments, the workbook template configuration interface 1900includes a set of workbook information options 1902, including fieldsfor entry of a workbook name and workbook description, an interfaceelement that can be used to set the current workbook as a defaultworkbook, and an interface element that can be used to designate whetherusers are required to create a note upon completion of workbook tasks.In some embodiments, the workbook template configuration interface 1900further includes a phases definition panel 1904. The example shown inFIG. 19 illustrates the definition of a single phase; however, aworkbook template generally can include any number of separate phases asdesired by the user. As illustrated in FIG. 19, the phases definitionpanel 1904 include a field 1908 for entry of a phase name and an addtask button 1910 used to add tasks to the phase. In FIG. 19, an example“Data Breach” workbook template includes a phase named “Escalate toaccountable system owners.” The phase named “Escalate to accountablesystem owners” includes three tasks: a task 1906A named “Identifyaccountable system owners,” a task 1906B named “Notify accountablesystem owners,” and a task 1906C named “Setup collaboration channels.”Each of the tasks 1906A-1906C includes fields for the task name and theowner (e.g., a user who can be designated as being responsible for theassociated task), and a selector button to designate that a notificationshould be sent upon completion of the task. In response to selecting aspecific task within a phase, the workbook editor displays additionaloptions for the corresponding task. As illustrated in FIG. 19, selectedtask 1906A includes a field for entry of text for a description of thetask, in addition to options to add or remove executable actions andplaybooks. The set of executable actions associated with task 1906Aincludes the track_active_directory_admin_users playbook, as well asindividual actions, including run query, list oncalls, get oncall, getsystem attributes, get user attributes, get users, and ask question.

FIG. 20 illustrates an example workbook template review interfacedisplaying information related to a defined workbook template accordingto some embodiments. For example, as illustrated in the workbooktemplate review interface 2000 shown in FIG. 20, the phases of a created“Data Breach” workbook template include: a phase 2002A labeled “Escalateto accountable system owners,” a phase 2002B labeled “Stop theexfiltration,” a phase 2002C labeled “Remove persistent adversaries,”and a phase 2002D labeled “Assess impact.” Additional phases notpictured can include, for example, phases labeled “Report to appropriatestakeholders” and “Prevent future breaches.” As illustrated in FIG. 20,the tasks associated with the phase 2002B include: “Identify likelymeans of exfiltration,” “Determine mitigations and remediations,” and“Stop exfiltration”; the tasks associated with phase 2002C include:“Identify likely means of persistence” and “Removed identifiedpersistence mechanisms”; and the task for phase 2002D include: “Measurethe size and scope.” The workbook template review interface 2000 furtherdisplays, for each task, an indication of a number of actions andplaybooks associated with the task, as well as an owner of the task, ifany. A user can select an edit button 2004 to further configure theworkbook template, if desired.

FIG. 21 illustrates an example of a “mission control” interface of an ITand security operations application (e.g., IT and security operationsapplication 1602) displaying information related to an occurrence of anincident in an IT environment according to some embodiments. In someembodiments, the mission control interface 2100 displays one or moreexecutable actions for responding to the incident as part of a workbookthat is generated based on the identified incident. The mission controlinterface 2120 shown in FIG. 21 includes, for example, an eventinformation panel 2102, a tasks panel 2104, a set of suggestedexecutable actions 2106 associated with a particular task, and a head-updisplay (HUD) panel 2108.

6.0. Securely Executing Custom Playbook Code

IT and security operations applications, such as the IT and securityoperations application 1602 described herein, can be used for a varietyof orchestration, automation, and response tasks related to users' ITenvironments. Typically, a user's IT environment includes many differenttypes of computing devices, software applications, and other services.As used herein, the various types of devices and applications related tousers' IT environments and with which an IT and security operationsapplication 1602 can potentially communicate with or control arereferred to broadly as “computing assets.” The assets comprising anexemplary user's IT environment might include various types of clientcomputing devices (e.g., desktop computers, laptops, mobile devices,servers, etc.), networking devices (e.g., routers, switches, firewalls,etc.), software applications (e.g., operating systems, virtual machinemanagers (VMMs), security applications, user applications, etc.),services (e.g., threat intelligence services, user management services,cloud-based services, etc.), and the like.

As indicated herein, users can create and use playbooks that areexecutable by an IT and security operations application 1602. Thecreation and execution of playbooks in an IT and security operationsapplication 1602 allows users to automate a wide variety of operationsrelated to a user's IT environment (e.g., including operations such asmodifying firewall settings, quarantining devices, communicating withother internal or external services, restarting servers, etc.). In someembodiments, a playbook is comprised of a set of defined codeblocks eachcontaining program code (e.g., Python code) that performs definedfunctionality when the codeblock is encountered during execution of aplaybook of which it is a part (e.g., execution of one codeblock mightcause a playbook execution engine to obtain additional information aboutan incident attribute from an internal or external service, whileanother codeblock might use an “app” or “connector” to instruct afirewall to block an IP address, and so forth). Playbooks are furtherassociated with a control flow that defines an order in which aplaybook's codeblocks are executed, where a playbook's control flow mayvary during each execution depending on the particular input conditions,e.g., based on attributes of an incident that triggers execution of theplaybook. During execution, input and output values can pass from onecodeblock to another.

The IT and security operations application 1602 can provide pre-definedcodeblocks, which users can use to build playbooks. In some embodiments,in addition to using various types of codeblocks that are pre-definedand provided to users of the IT and security operations application1602, the application further allows users to add custom code to aplaybook, e.g., by modifying the program code associated with apre-defined codeblock, inserting custom code into a “global” portion ofthe playbook's code, or by adding custom codeblocks to a playbook'scontrol flow. Custom code is code entered by a user and/or in the user'snetwork, for example, by typing code into the playbook editor or copieslines of code into the playbook editor, among other examples. The typesof functionality that a user can add to a playbook using custom code isvirtually limitless; however, this also means that various types ofsoftware defects and security issues may be inadvertently or maliciouslyintroduced into a playbook via custom code. In an entirely on-premisesimplementation of an IT and security operations application (e.g., wherean instance of the application runs within a user's own network and onthe user's own hardware resources), the risks associated with user-addedcustom code are borne primarily by the user since the custom codeexecutes only within the user's own IT environment. However, for animplementation of an IT and security operations application 1602 thatexecutes entirely or partially using resources provided by a cloudprovider network 1604, the execution of arbitrary custom code isassociated with risks that can impact the performance and security ofnot only a particular user's cloud-based application but also that ofother users and applications running in the same cloud-basedenvironment.

The aforementioned challenges, among others, are addressed in someembodiments by techniques for enabling a cloud-based IT and securityoperations application 1602 to execute playbooks containing custom codein a manner that mitigates various types of risk related to the misuseof cloud-based resources and security of user data. According toembodiments, users use a client application (e.g., a web browser) tointerface with a cloud-based IT and security operations application 1602over a network, where the interfaces provided by the IT and securityoperations application include interfaces enabling users to create andmodify playbooks. Upon receiving input from a user to save a playbookunder development in the client application, the client applicationdetermines whether the playbook includes custom code (e.g., JavaScript®code executing as part of a web-based interface may identify thepresence of custom code in a playbook under development in a web-basedplaybook editor, or a mobile application providing a playbook editor mayinclude logic to detect custom code). If the client applicationdetermines that the playbook includes custom code, the clientapplication establishes a connection with a proxy application (alsoreferred to as an “automation broker”) running in the user's ownon-premises network and sends a representation of the playbook to theproxy application. The client application further sends to the IT andsecurity operations application 1602 an identifier of the playbook andan indication that the playbook (or the custom code portions of theplaybook) is stored within the user's on-premises network, whichinformation the IT and security operations application stores in thecloud in association with the user's account.

In some embodiments, in response to the IT and security operationsapplication 1602 receiving a request to execute a playbook includingcustom code and that is stored in the user's on-premises environment(e.g., responsive to a manual request to execute the playbook, orresponsive to identification of an incident causing an automaticallytriggered execution of the playbook), the IT and security operationsapplication 1602 determines whether the program code implementing theplaybook is stored in the cloud-based environment or in the user'son-premises network. In response to determining that the playbook'sprogram code is stored in the user's on-premises network, the IT andsecurity operations application 1602 sends a request to the proxyapplication in the user's network instructing execution of the playbook.The proxy application then causes the playbook (or at least the customcode portions of a playbook) to be executed locally within the user'son-premises network (e.g., based on execution of the playbook by theproxy application or by a separate playbook execution engine running ona server in the tenant's network) against assets in the environment andpossibly against assets outside of the user's environment. Execution ofthe playbook, including execution of the custom code, is thus performedentirely outside of the cloud-based environment in which the IT andsecurity operations application resides, thereby reducing the risk ofcustom code affecting other computing resources and data residing in thecloud provider network.

FIG. 27 is a block diagram illustrating an example networked computingenvironment including an IT and security operations application 1602,and further illustrating a process for enabling the secure execution ofcustom playbook code as described above. For example, the numberedcircles “1”-“8” in the networked computing environment 2700 of FIG. 27generally illustrate an example process that includes a user of asecurity team 1606A using a visual playbook editor 2706 to create aplaybook 2710 including custom code 2708 and saving the playbook, aclient application 2704 determining that the playbook 2710 includes thecustom code 2708, sending the playbook including the custom code to anIT environment associated with the user creating the playbook (e.g., anIT environment running in tenant network 1610A), and subsequentlysecurely executing the custom code within the user's own IT environment.

In some embodiments, at circle “1” in FIG. 23, a user uses a clientapplication 2704 (e.g., a web browser, mobile app, or other clientapplication) running on a client device 2702 to access interfacesprovided by the IT and security operations application 1602 running inthe provider network 1604. The interfaces can include, for example,web-based interfaces implemented as a web-based console provided via afront end service 1608, GUIs implemented by a mobile app or otherstandalone application, interfaces accessed via command line interface(CLI), interfaces accessed via another type of application communicatingusing an application programming interface (API) provided by theapplication 1602, or the like. In some embodiments, the interfaces caninclude a “mission control” interface (e.g., a home interface for theapplication where analysts can view incidents in one place), a playbooklist interface, a visual playbook editor, among other possibleinterfaces that enable a user to interact generally with various aspectsof an IT and security operations application 1602.

In some embodiments, a user (e.g., a member of a security team 1606A)uses a client application 2704 to access a visual playbook editorprovided by the IT and security operations application 1602. Forexample, a user may desire to create a new playbook or to modify anexisting playbook using a visual playbook editor and, in some scenarios,a user adds custom code 2708 to a playbook 2710. As described herein inreference to FIGS. 22-25, for example, a user may add custom code to aplaybook by modifying code associated with a pre-defined codeblock,modifying a “global” portion of the playbook's code, or adding a customcodeblock to a playbook graph. Because the custom code is input by theuser and/or within the user's network, the IT and security operationsapplication AA02 may not be aware of the contents of the customcodeblock, and/or what operations the custom code block would executewhen run. At any point during the development of a playbook, a user mayfurther provide input requesting to save a playbook 2710 underdevelopment (e.g., to cause a current version of the playbook code to besaved in association with the user's account so that it can be executed,as desired). In some embodiments, a visual playbook editor may cause aplaybook 2710 under development to be saved automatically on a periodicbasis or in response to detecting that a user has updated the playbook.

In some embodiments, to provide a visual playbook editor, the IT andsecurity operations application 1602 executing in the cloud providernetwork 1604 sends resources to the user's network, which can be used bya client device 2702 to display a GUI including a visual playbook editor2706. As indicated above, a visual playbook editor enables creation of aplaybook including a collection of interrelated code blocks that definean ordered set of operations to be performed in response toidentification of incidents in an IT environment. In some embodiments,the resources sent from the IT and security operations application 1602to provide a visual playbook editor interface includes one or more HTMLfiles, Cascading Style Sheets (CSS), and/or other data used to definethe presentation semantics of the visual playbook editor 2706. Theresources may further include client-side executable logic (e.g.,JavaScript® code or other client-side executable logic) used to performvarious types of dynamic behavior. In other embodiments, the visualplaybook editor is provided by a mobile app or other client applicationthat includes client-side executable logic that can be used to create,modify, and save playbooks. In some embodiments, the client-sideexecutable logic includes logic used to determine whether the playbookunder development includes custom code and, upon detecting that a userdesires to save a playbook containing custom code, perform variousoperations to enable secure execution of the custom code as describedhereinafter.

In some embodiments, in response to detecting a user request to save amodified playbook, or in response to detecting an automatic operation tosave a modified playbook, the client application 2704 determines whetherthe playbook 2710 includes custom code 2708. As described above, if theclient application 2704 is a web browser, client-side executable codesuch as JavaScript® can be executed that analyzes the code associatedwith the playbook 2710 to determine whether any custom code 2708 ispresent, while other types of client applications can similarly detectthe presence of custom code. In some embodiments, the detection ofcustom code 2708 includes determining whether a user has modified aglobal section of the playbook code, modified code associated with anypredefined codeblocks, has added any custom codeblocks, and/or hasmodified default code provided by the visual playbook editor. In someembodiments, a visual playbook editor 2706 sets a flag or otherindicator any time that it detects that a user has added custom code toa playbook and the detection of whether custom code 2708 is present uponsaving the playbook can include determining whether the flag or otherindicator has been set.

In some embodiments, upon saving a playbook that does not include customcode, a client application 2704 may send data representing the playbook(e.g., source code, XML, JSON, JavaScript, another structured way inwhich to describe the codeblocks and connections between codeblocks,and/or a combination of the preceding) to the IT and security operationsapplication 1602 executing within a provider network 1604. In thisscenario, the IT and security operations application 1602 may save theplaybook data in association with the user's account at storageresources provisioned in the provider network 1604, and may furtherexecute the playbook on demand using compute resources provisionedwithin the provider network 1604. However, as described above, inscenarios where a playbook includes custom code, it may be desirable toenable execution of the playbooks outside of the provider network 1604at which the IT and security operations application 1602 resides. Insome embodiments, at circle “2,” responsive to determining that theplaybook 2710 includes custom code 2708, the client application 2704instead sends a representation of the playbook, or a representation ofthe custom code portions of the playbook, to a proxy application (e.g.,an on-premises proxy 1612) executing on a server in the user's ownon-premises network 1610A.

In some embodiments, the client application 2704 interfaces with a“tunnel bridge” 2712 to send communications to and receivecommunications from an on-premises proxy 1612 and automation broker 1620executing in the tenant network 1610A. In some embodiments, the tunnelbridge operates as a tunnel bridge service that establishes WebSocket,or other types of secure connections. For example, the tunnel bridge canestablish a WebSocket connection to the client application 2704 and aseparate WebSocket connection to an on-premises proxy 1612. In someembodiments, the tunnel bridge 2712 establishes the connections using ahandshake technique with each particular device that is to communicateover the tunnel bridge 2712. In some embodiments, the connection enablestwo-way communications between the tunnel bridge 2712 and a devicewithout opening a port in a firewall. In some embodiments, the tunnelbridge 2712 is a cloud-based service (for example, the tunnel bridge2712 is an application that can execute from a provider network 1604).In other embodiments, the tunnel bridge 2712 can execute from anothernon-cloud-based hardware device.

In some embodiments, the tunnel bridge 2712 may perform authenticationoperations with other devices in order to establish trust and may thenestablish secure communications channels with the other devices, wherethe tunnel bridge 2712 and other devices can transmit securecommunications using the secure communications channels. In someembodiments, the tunnel bridge 2712 provides end-to-end encryption(E2EE) of communications between a client application 2704 and anon-premises proxy 1612 by transmitting one or more encrypted datapackets between the client application 2704 and the on-premises proxy1612. In some embodiments, communications sent through the tunnel bridge2712 are in the form of data packets, where each data packet includes,at least, a payload and a device identifier for a destination devicethat indicate the device that is to receive the data packet. In otherembodiments, the data packet can also include a device identifier forthe source device or an instance identifier that indicates an IT andsecurity operations instance associated with the data packet. In someembodiments, the data packet is encrypted prior to being transmitted tothe tunnel bridge 2712. While in some embodiments, the tunnel bridge2712 decrypts the data packet before sending the data packet to itsintended destination, in other embodiments, the tunnel bridge 2712forwards the encrypted data packet to its intended destination withoutperforming a decryption process.

In some embodiments, the client application 2704 communicates with thetunnel bridge 2712 across a network, and the tunnel bridge 2712communicates with the on-premises proxy 1612 across the network 206.These networks can be communications networks, such as a local areanetwork (LAN), wide area network (WAN), cellular network (e.g., LTE,HSPA, 3G, 4G, and/or any other network based on cellular technologies),and/or networks using any of wired, wireless, terrestrial microwave, orsatellite links. In some embodiments, a client application 2704initiates a process to establish a secure connection (e.g., a WebSocketconnection) with a tunnel bridge 2712 (e.g., upon saving a playbookcontaining custom code, or any point in time before or after a playbookis saved). For example, the tunnel bridge 2712 establishes the secureconnection and associates the secure connection with a device identifierfor the mobile device.

In some embodiments, the tunnel bridge 2712 includes a database thatstores document data structures and one or more keys. In someembodiments, the database is in the same network as the tunnel bridge2712. In some embodiments, the database stores data packets received bythe tunnel bridge 2712. In some embodiments, the database can be astructured query language (SQL) database, or a NoSQL database, such asan AMAZON® DynamoDB. In some embodiments, the database includes a keystore that stores encryption keys, including single-use session keys andlong-term keys associated with devices that send E2EE communications. Insome embodiments, the database also includes a routing table thatincludes address information associated with devices included in thenetwork 206. In some embodiments, the tunnel bridge 2712 sends queriesto the database in order to determine, based on a device identifier in aparticular data packet, the address of the intended recipient of theparticular data packet.

As illustrated in FIG. 27, the tunnel bridge 2712 communicates with anautomation broker 1620 through an on-premises proxy 1612. Theon-premises proxy 1612 is a process executing on the tenant network1610A that operates as a gateway between the tunnel bridge 2712 and theIT and security operations application 1602 and other devices includingclient device 2702. The on-premises proxy 1612 is configured to receiverequests (e.g., from the client application 2704) and translate therequests into API requests that are sent to an automation broker 1620 orother local components for execution. The on-premises proxy 1612 canalso be configured to generate and send messages (e.g., notifications,alerts, etc.) to the client application 2704 executing on a clientdevice 2702. In some embodiments, the on-premises proxy 1612 sendsmessages in accordance with a push notification service associated withthe mobile device, such as the APPLE® Push Notification service (APN),or GOOGLE® Cloud Messaging (GCM). For example, the on-premises proxy1612 can send messages in a format or configuration that isunderstandable by the push notification service associated with a mobiledevice. In some embodiments, the on-premises proxy 1612 sends themessages to a mobile device push notification service via the tunnelbridge 2712. In some embodiments, a client device 2702 receives variousschemas, dashboards, playbooks, runbooks, cards, and/or visualizationsthat include real-time data associated with performance metrics of aparticular machine associated with an IT and security operationsinstance. In some embodiments, the on-premises proxy 1612 is configuredto perform the management, generations, and registration of keys.

In some embodiments, the tunnel bridge 2712 facilitates communicationsbetween a client application 2704 and a cloud-based IT and securityoperations application 1602 executing on a provider network 1604 (e.g.,AWS, Microsoft Azure, Google Cloud, etc.). In such embodiments, thecloud-based IT and security operations application 1602 is a cloud-basedimplementation of an IT and security operations application that mayoperate in tenant networks.

In some embodiments, the representation of a playbook 2710 sent to thetenant's network 1610A may include data identifying any of: thecodeblocks associated with the playbook 2710, any code included in aglobal playbook portion, connections between codeblocks, identifiers ofcodeblocks that start or end the playbook, and other types of metadataassociated with the playbook (e.g., an identifier of the playbook, auser-readable name of the playbook, information indicating theplaybook's creation time, last update time, etc.). In some embodiments,a playbook 2710 is represented using a JSON-formatted description thatincludes metadata related to the playbook, identifies the codeblockscomprising the playbook, and further includes any custom code includedin the playbook. In some embodiments, the data corresponding to thecustom code 2708 can be included with the remainder of the playbook orbe packaged and sent to the on-premises proxy application separate fromthe other playbook data. In some embodiments, only portions of theplaybook 2710 containing custom code are sent to the on-premises proxyapplication while the other playbook data is sent to the IT and securityoperations application 1602.

In some embodiments, at circle “3,” the on-premises proxy 1612 receivesand sends the data to an on-premises proxy application (e.g., anautomation broker 1620 or other component within the on-premises network1610A). In some embodiments, the on-premises proxy applicationgenerates, based on the representation of the playbook received from theclient application 2704, the program code to be used to execute theplaybook upon request. The proxy application 1612, or another componentin the tenant's network 1610A, may generate the playbook code at anypoint in time after receiving the playbook representation from theclient application 2704. In some embodiments, the proxy application 1612generates the playbook code in part based on defined relationshipsbetween pre-defined code blocks and associated code segments, where thepre-defined code blocks may be identified in the data sent from theclient application 2704 with or without the corresponding program code.

In some embodiments, the on-premises proxy application stores theplaybook's program code and possibly other metadata in a localrepository (e.g., a version-control system or other type of datarepository). In some embodiments, the pre-defined codeblocks and customcode blocks are each stored as independent, version-controlledapplication modules that can be individually extracted and executed by aplaybook execution engine on demand. In other embodiments, the playbookcode is stored as a standalone executable application that can beinvoked on demand.

In some embodiments, at circle “4,” the client application also sendsplaybook data to the IT and security operations application 1602, wherethe playbook data includes an identifier of the playbook and anindication that the playbook code (or portions thereof) are stored inthe user's on-premises network. The playbook data sent to the IT andsecurity operations application 1602 can be sent before, after, orconcurrently with the data sent to the user's on-premises network 1610A.For example, whereas a playbook that does not include custom code may besent to the IT and security operations application 1602 for storage andmanagement, in some embodiments, only data identifying a playbookincluding custom code (e.g., including an indication of an externalstorage location of the playbook) is sent to the IT and securityoperations application 1602 for storage.

In some embodiments, at circle “5,” the IT and security operationsapplication 1602 stores, in association with the user's account, thedata related to the playbook 2710 for which the update was sent from theclient device 2702. The stored data related to the playbook can include,for example, an identifier of the playbook, other playbook metadata, andcan further include an indication that the playbook (or one or moreportions thereof) is stored in the user's on-premises network 1610A. Theplaybook data can be stored in association with the user's account, forexample, such that the user can view information about the playbook invarious playbook management interfaces.

In some embodiments, at circle “6,” the IT and security operationsapplication 1602 receives a request to execute the playbook. In someembodiments, a playbook is executed responsive to the IT and securityoperations application 1602 identifying one or more incidents that causethe playbook to be triggered automatically. As mentioned, an incident isa data structure representing incident data obtained from a tenantnetwork, and is further associated with various events, artifacts, andother incident-related data. In some embodiments, incidents are storedin association with a tenant identifier (e.g., an identifier of anentity associated with one or more of tenant networks 1610A-1610N fromwhich the data associated with the incident originated). Furthermore, insome embodiments, users can configure playbooks to be automaticallytriggered responsive to the IT and security operations application 1602identifying one or more incidents of a particular type or that areassociated with particular attributes. In other scenarios, a playbookcan be executed responsive to a user manually selecting the playbook forexecution, possibly relative to one or more user-identified incidents.

In some embodiments, at circle “7,” the IT and security operationsapplication 1602 determines that the playbook to be executed (or one ormore portions thereof containing custom code) is stored in the user'son-premises network 1610A. For example, the IT and security operationsapplication 1602 may determine that the playbook is stored remotelybased on the data obtained from the client application 2704 upon theplaybook being saved. In some embodiments, in response to detecting thatthe playbook (or the custom code portion of the playbook) are storedremotely in a tenant network, the IT and security operations application1602 sends a request to the proxy application executing in the user'son-premises network to execute the playbook locally (e.g., a requestsent by an action manager 1618 or other component to the automationbroker 1620 via the tunnel bridge 2712 and on-premises proxy 1612). Insome embodiments, the request instructs the proxy application (e.g., aplaybook execution engine or other component of an automation broker1620) to execute the entire playbook (e.g., by including an identifierof the playbook in the request) and may further include one or moreinput values associated with a user request to execute the playbook orassociated with an identified incident triggering execution of theplaybook. In other embodiments, the OAR service 1616 partially executesthe playbook (e.g., portions of the playbook that do not include customcode) and sends requests for custom code portions of the playbook to beexecuted in the user's on-premises network, as described above.

In some embodiments, at circle “8,” the proxy application in the user'son-premises network receives the request, obtains the playbook code fromthe repository, and executes the playbook (or custom code portionsthereof). In some embodiments, execution of the playbook includesperforming actions against computing assets 1614 within the user'son-premises network and possibly with other assets and services outsideof the network. For example, a playbook can involve actions that involveone or more IT assets 1614, obtain information from external datasources or services, cause the performance of actions involvingcomputing assets located within a provider network 1604 (e.g., actionsinvolving configuring network settings, starting or stopping servers,etc.), and so forth.

In some embodiments, execution of the playbook involves extracting theplaybook code from the storage repository in the user's on-premisesnetwork 1610A, and using compute resources (e.g., physical servers, VMs,containers, etc.) to execute the playbook code. In some embodiments, aplaybook engine is configured to dynamically extract portions of theplaybook code and execute the code on demand as needed. For example,depending on a particular code flow of a given playbook execution, aplaybook engine can extract the code associated with particularcodeblocks of the playbook and execute those portions on demand, wherethe extracted and executed code can include blocks of custom code asdescribed above. In some embodiments, execution of a playbook within anon-premises network 1610A can include storing data reflectingperformance of the actions including, for example, data indicatingsearches queries that were executed, types of actions performed againstassets related to an associated IT environment, indications of when theactions were performed, response information received from assetsagainst which the actions were executed, an identifier of the user andassociated tenant that requested the action, among other possibleinformation. This information may be stored locally in the user'snetwork and may also be sent to the IT and security operationsapplication 1602 for storage as tenant data in a data store managed bythe IT and security operations application 1602, data intake and querysystem 108, or both. Some portions of the data may be stored as metadatain association with the incident, in association with artifacts of theincident (for example, to indicate searches and actions performedinvolving particular IP addresses, file hashes, usernames, and soforth), in association with the user(s) and tenants performing theactions, and in association with possibly other data attributes storedacross the IT and security operations application 1602.

FIG. 28 is a flow diagram illustrating operations 2800 of a method forenabling a cloud-based IT and security operations application to executeplaybooks containing custom code in a manner that mitigates types ofrisk related to the misuse of cloud-based resources and security of userdata according to some embodiments. Some or all of the operations 2800(or other processes described herein, or variations, and/or combinationsthereof) are performed under the control of one or more computer systemsconfigured with executable instructions and are implemented as code(e.g., executable instructions, one or more computer programs, or one ormore applications) executing collectively on one or more processors, byhardware or combinations thereof. The code is stored on acomputer-readable storage medium, for example, in the form of a computerprogram comprising instructions executable by one or more processors.The computer-readable storage medium is non-transitory. In someembodiments, one or more (or all) of the operations 2800 are performedby an IT and security operations application 1602, client device 2702,automation broker 1620, among other possible components of the otherfigures.

The operations 2800 include, at block 2802, sending, by an informationtechnology (IT) and security operations application executing in a cloudprovider network, resources for displaying a graphical user interface(GUI), the GUI including a playbook editor, wherein the playbook editorenables generation of a playbook, the playbook including a collection ofinterrelated code blocks that define an ordered set of operations to beperformed in response to identification of incidents in an ITenvironment, and wherein a user's network uses the IT and securityoperations application to manage security incidents in the user'snetwork.

In some embodiments, the operations further include receiving, by theclient device, input requesting to save the playbook including thecustom code; detecting the presence of the custom code in the playbook;establishing a connection with the proxy application in the user'snetwork; and sending a representation of the playbook including thecustom code to the proxy application. In some embodiments, a clientdevice establishes a connection to the proxy application using a tunnelbridge that establishes a secure connection between the client deviceand the tunnel bridge and between the tunnel bridge and the proxyapplication in the user's network.

In some embodiments, the operations further include receiving, by theclient device, first input causing addition, to the playbook, of a noderepresenting a custom code function block, second input specifying anoutput variable associated with the custom code function block, andthird input creating a connection between the node representing thecustom code function block and another node of the graph of theplaybook.

In some embodiments, the resources used by the client device to displaythe GUI including the playbook editor include data used to display aweb-based playbook editor and further include client-side executablelogic used to detect the presence of the custom code in the playbook. Insome embodiments, the resources used by the client device to display theGUI including the playbook editor include playbook data used by a clientapplication to display the playbook in the playbook editor.

In some embodiments, the playbook stored in a version-control systemrepository in the user's network and is executed by a playbook executionengine running on compute resources in the user's network. In someembodiments, the client device sends, to the proxy application, arepresentation of the playbook using a structured data format, whereinthe structured data format identifies one or more predefined code blocksassociated with the playbook and one or more portions of custom code.

The operations 2800 further include, at block 2804, receiving, by the ITand security operations application, an indication that the playbookincludes custom code, wherein the custom code is input at the user'snetwork and is not provided by the IT and security operationsapplication, and wherein the playbook is stored at a server locatedwithin the user's network.

The operations 2800 further include, at block 2806, receiving a requestto execute the playbook. In some embodiments, the request to execute theplaybook is generated automatically responsive to the IT and securityoperations application identifying an incident.

The operations 2800 further include, at block 2808, sending, to a proxyapplication executing in the user's network, a request to execute theplaybook including the custom code, the request causing execution of theplaybook in the user's network. In some embodiments, the IT and securityoperations application executes at least a portion of the playbook usingcompute resources provided by the cloud provider network.

In some embodiments, execution of the playbook in the user's networkincludes performing an action that involves interaction with a computingresource running in the cloud provider network. In some embodiments, theproxy application includes a playbook execution engine that executes theplaybook, wherein execution of the playbook by the playbook executionengine includes obtaining portions of the playbook from a datarepository and executing the portions of the playbook on demand.

In some embodiments, the request to execute the playbook is a firstrequest to execute a first playbook, and wherein the operations furtherinclude: receiving a second request to execute a second playbook,wherein the second playbook does not include custom code; executing thesecond playbook using computing resources of the cloud provider network.

In some embodiments, the IT and security operations application obtainsdata related to incidents from a data intake and query system running inthe cloud provider network.

FIG. 29 is a block diagram that illustrates a computer system 2900utilized in implementing the above-described techniques, according to anembodiment. Computer system 2900 may be, for example, a desktopcomputing device, laptop computing device, tablet, smartphone, serverappliance, computing mainframe, multimedia device, handheld device,networking apparatus, or any other suitable device.

Computer system 2900 includes one or more buses 2902 or othercommunication mechanism for communicating information, and one or morehardware processors 2904 coupled with buses 2902 for processinginformation. Hardware processors 2904 may be, for example, generalpurpose microprocessors. Buses 2902 may include various internal and/orexternal components, including, without limitation, internal processoror memory busses, a Serial ATA bus, a PCI Express bus, a UniversalSerial Bus, a HyperTransport bus, an Infiniband bus, and/or any othersuitable wired or wireless communication channel.

Computer system 2900 also includes a main memory 2906, such as a randomaccess memory (RAM) or other dynamic or volatile storage device, coupledto bus 2902 for storing information and instructions to be executed byprocessor 2904. Main memory 2906 also may be used for storing temporaryvariables or other intermediate information during execution ofinstructions to be executed by processor 2904. Such instructions, whenstored in non-transitory storage media accessible to processor 2904,render computer system 2900 a special-purpose machine that is customizedto perform the operations specified in the instructions.

Computer system 2900 further includes one or more read only memories(ROM) 2908 or other static storage devices coupled to bus 2902 forstoring static information and instructions for processor 2904. One ormore storage devices 2910, such as a solid-state drive (SSD), magneticdisk, optical disk, or other suitable non-volatile storage device, isprovided and coupled to bus 2902 for storing information andinstructions.

Computer system 2900 may be coupled via bus 2902 to one or more displays2912 for presenting information to a computer user. For instance,computer system 2900 may be connected via a High-Definition MultimediaInterface (HDMI) cable or other suitable cabling to a Liquid CrystalDisplay (LCD) monitor, and/or via a wireless connection such aspeer-to-peer Wi-Fi Direct connection to a Light-Emitting Diode (LED)television. Other examples of suitable types of displays 2912 mayinclude, without limitation, plasma display devices, projectors, cathoderay tube (CRT) monitors, electronic paper, virtual reality headsets,braille terminal, and/or any other suitable device for outputtinginformation to a computer user. In an embodiment, any suitable type ofoutput device, such as, for instance, an audio speaker or printer, maybe utilized instead of a display 2912.

One or more input devices 2914 are coupled to bus 2902 for communicatinginformation and command selections to processor 2904. One example of aninput device 2914 is a keyboard, including alphanumeric and other keys.Another type of user input device 2914 is cursor control 2916, such as amouse, a trackball, or cursor direction keys for communicating directioninformation and command selections to processor 2904 and for controllingcursor movement on display 2912. This input device typically has twodegrees of freedom in two axes, a first axis (e.g., x) and a second axis(e.g., y), that allows the device to specify positions in a plane. Yetother examples of suitable input devices 2914 include a touch-screenpanel affixed to a display 2912, cameras, microphones, accelerometers,motion detectors, and/or other sensors. In an embodiment, anetwork-based input device 2914 may be utilized. In such an embodiment,user input and/or other information or commands may be relayed viarouters and/or switches on a Local Area Network (LAN) or other suitableshared network, or via a peer-to-peer network, from the input device2914 to a network link 2920 on the computer system 2900.

A computer system 2900 may implement techniques described herein usingcustomized hard-wired logic, one or more ASICs or FPGAs, firmware and/orprogram logic which in combination with the computer system causes orprograms computer system 2900 to be a special-purpose machine. Accordingto one embodiment, the techniques herein are performed by computersystem 2900 in response to processor 2904 executing one or moresequences of one or more instructions contained in main memory 2906.Such instructions may be read into main memory 2906 from another storagemedium, such as storage device 2910. Execution of the sequences ofinstructions contained in main memory 2906 causes processor 2904 toperform the process steps described herein. In alternative embodiments,hard-wired circuitry may be used in place of or in combination withsoftware instructions.

The term “storage media” as used herein refers to any non-transitorymedia that store data and/or instructions that cause a machine tooperate in a specific fashion. Such storage media may comprisenon-volatile media and/or volatile media. Non-volatile media includes,for example, optical or magnetic disks, such as storage device 2910.Volatile media includes dynamic memory, such as main memory 2906. Commonforms of storage media include, for example, a floppy disk, a flexibledisk, hard disk, solid state drive, magnetic tape, or any other magneticdata storage medium, a CD-ROM, any other optical data storage medium,any physical medium with patterns of holes, a RAM, a PROM, an EPROM, aFLASH-EPROM, NVRAM, any other memory chip or cartridge.

Storage media is distinct from but may be used in conjunction withtransmission media. Transmission media participates in transferringinformation between storage media. For example, transmission mediaincludes coaxial cables, copper wire and fiber optics, including thewires that comprise bus 2902. Transmission media can also take the formof acoustic or light waves, such as those generated during radio-waveand infra-red data communications.

Various forms of media may be involved in carrying one or more sequencesof one or more instructions to processor 2904 for execution. Forexample, the instructions may initially be carried on a magnetic disk ora solid state drive of a remote computer. The remote computer can loadthe instructions into its dynamic memory and use a modem to send theinstructions over a network, such as a cable network or cellularnetwork, as modulate signals. A modem local to computer system 2900 canreceive the data on the network and demodulate the signal to decode thetransmitted instructions. Appropriate circuitry can then place the dataon bus 2902. Bus 2902 carries the data to main memory 2906, from whichprocessor 2904 retrieves and executes the instructions. The instructionsreceived by main memory 2906 may optionally be stored on storage device2910 either before or after execution by processor 2904.

A computer system 2900 may also include, in an embodiment, one or morecommunication interfaces 2918 coupled to bus 2902. A communicationinterface 2918 provides a data communication coupling, typicallytwo-way, to a network link 2920 that is connected to a local network2922. For example, a communication interface 2918 may be an integratedservices digital network (ISDN) card, cable modem, satellite modem, or amodem to provide a data communication connection to a corresponding typeof telephone line. As another example, the one or more communicationinterfaces 2918 may include a local area network (LAN) card to provide adata communication connection to a compatible LAN. As yet anotherexample, the one or more communication interfaces 2918 may include awireless network interface controller, such as a 802.11-basedcontroller, Bluetooth controller, Long Term Evolution (LTE) modem,and/or other types of wireless interfaces. In any such implementation,communication interface 2918 sends and receives electrical,electromagnetic, or optical signals that carry digital data streamsrepresenting various types of information.

Network link 2920 typically provides data communication through one ormore networks to other data devices. For example, network link 2920 mayprovide a connection through local network 2922 to a host computer 2924or to data equipment operated by a Service Provider 2926. ServiceProvider 2926, which may for example be an Internet Service Provider(ISP), in turn provides data communication services through a wide areanetwork, such as the world-wide packet data communication network nowcommonly referred to as the “internet” 2928. Local network 2922 andInternet 2928 both use electrical, electromagnetic or optical signalsthat carry digital data streams. The signals through the variousnetworks and the signals on network link 2920 and through communicationinterface 2918, which carry the digital data to and from computer system2900, are example forms of transmission media.

In an embodiment, computer system 2900 can send messages and receivedata, including program code and/or other types of instructions, throughthe network(s), network link 2920, and communication interface 2918. Inthe Internet example, a server 2930 might transmit a requested code foran application program through Internet 2928, ISP 2926, local network2922 and communication interface 2918. The received code may be executedby processor 2904 as it is received, and/or stored in storage device2910, or other non-volatile storage for later execution. As anotherexample, information received via a network link 2920 may be interpretedand/or processed by a software component of the computer system 2900,such as a web browser, application, or server, which in turn issuesinstructions based thereon to a processor 2904, possibly via anoperating system and/or other intermediate layers of softwarecomponents.

In an embodiment, some or all of the systems described herein may be orcomprise server computer systems, including one or more computer systems2900 that collectively implement various components of the system as aset of server-side processes. The server computer systems may includeweb server, application server, database server, and/or otherconventional server components that certain above-described componentsutilize to provide the described functionality. The server computersystems may receive network-based communications comprising input datafrom any of a variety of sources, including without limitationuser-operated client computing devices such as desktop computers,tablets, or smartphones, remote sensing devices, and/or other servercomputer systems.

7.0. Terminology

Computer programs typically comprise one or more instructions set atvarious times in various memory devices of a computing device, which,when read and executed by at least one processor, will cause a computingdevice to execute functions involving the disclosed techniques. In someembodiments, a carrier containing the aforementioned computer programproduct is provided. The carrier is one of an electronic signal, anoptical signal, a radio signal, or a non-transitory computer-readablestorage medium.

Any or all of the features and functions described above can be combinedwith each other, except to the extent it may be otherwise stated aboveor to the extent that any such embodiments may be incompatible by virtueof their function or structure, as will be apparent to persons ofordinary skill in the art. Unless contrary to physical possibility, itis envisioned that (i) the methods/steps described herein may beperformed in any sequence and/or in any combination, and (ii) thecomponents of respective embodiments may be combined in any manner.

Although the subject matter has been described in language specific tostructural features and/or acts, it is to be understood that the subjectmatter defined in the appended claims is not necessarily limited to thespecific features or acts described above. Rather, the specific featuresand acts described above are disclosed as examples of implementing theclaims, and other equivalent features and acts are intended to be withinthe scope of the claims.

Conditional language, such as, among others, “can,” “could,” “might,” or“may,” unless specifically stated otherwise, or otherwise understoodwithin the context as used, is generally intended to convey that certainembodiments include, while other embodiments do not include, certainfeatures, elements and/or steps. Thus, such conditional language is notgenerally intended to imply that features, elements and/or steps are inany way required for one or more embodiments or that one or moreembodiments necessarily include logic for deciding, with or without userinput or prompting, whether these features, elements and/or steps areincluded or are to be performed in any particular embodiment.Furthermore, use of “e.g.,” is to be interpreted as providing anon-limiting example and does not imply that two things are identical ornecessarily equate to each other.

Unless the context clearly requires otherwise, throughout thedescription and the claims, the words “comprise,” “comprising,” and thelike are to be construed in an inclusive sense, as opposed to anexclusive or exhaustive sense, i.e., in the sense of “including, but notlimited to.” As used herein, the terms “connected,” “coupled,” or anyvariant thereof means any connection or coupling, either direct orindirect, between two or more elements; the coupling or connectionbetween the elements can be physical, logical, or a combination thereof.Additionally, the words “herein,” “above,” “below,” and words of similarimport, when used in this application, refer to this application as awhole and not to any particular portions of this application. Where thecontext permits, words using the singular or plural number may alsoinclude the plural or singular number respectively. The word “or” inreference to a list of two or more items, covers all of the followinginterpretations of the word: any one of the items in the list, all ofthe items in the list, and any combination of the items in the list.Likewise the term “and/or” in reference to a list of two or more items,covers all of the following interpretations of the word: any one of theitems in the list, all of the items in the list, and any combination ofthe items in the list.

Conjunctive language such as the phrase “at least one of X, Y and Z,”unless specifically stated otherwise, is understood with the context asused in general to convey that an item, term, etc. may be either X, Y orZ, or any combination thereof. Thus, such conjunctive language is notgenerally intended to imply that certain embodiments require at leastone of X, at least one of Y and at least one of Z to each be present.Further, use of the phrase “at least one of X, Y or Z” as used ingeneral is to convey that an item, term, etc. may be either X, Y or Z,or any combination thereof.

In some embodiments, certain operations, acts, events, or functions ofany of the algorithms described herein can be performed in a differentsequence, can be added, merged, or left out altogether (e.g., not allare necessary for the practice of the algorithms). In certainembodiments, operations, acts, functions, or events can be performedconcurrently, e.g., through multi-threaded processing, interruptprocessing, or multiple processors or processor cores or on otherparallel architectures, rather than sequentially.

Systems and modules described herein may comprise software, firmware,hardware, or any combination(s) of software, firmware, or hardwaresuitable for the purposes described. Software and other modules mayreside and execute on servers, workstations, personal computers,computerized tablets, PDAs, and other computing devices suitable for thepurposes described herein. Software and other modules may be accessiblevia local computer memory, via a network, via a browser, or via othermeans suitable for the purposes described herein. Data structuresdescribed herein may comprise computer files, variables, programmingarrays, programming structures, or any electronic information storageschemes or methods, or any combinations thereof, suitable for thepurposes described herein. User interface elements described herein maycomprise elements from graphical user interfaces, interactive voiceresponse, command line interfaces, and other suitable interfaces.

Further, processing of the various components of the illustrated systemscan be distributed across multiple machines, networks, and othercomputing resources. Two or more components of a system can be combinedinto fewer components. Various components of the illustrated systems canbe implemented in one or more virtual machines or an isolated executionenvironment, rather than in dedicated computer hardware systems and/orcomputing devices. Likewise, the data repositories shown can representphysical and/or logical data storage, including, e.g., storage areanetworks or other distributed storage systems. Moreover, in someembodiments the connections between the components shown representpossible paths of data flow, rather than actual connections betweenhardware. While some examples of possible connections are shown, any ofthe subset of the components shown can communicate with any other subsetof components in various implementations.

Embodiments are also described above with reference to flow chartillustrations and/or block diagrams of methods, apparatus (systems) andcomputer program products. Each block of the flow chart illustrationsand/or block diagrams, and combinations of blocks in the flow chartillustrations and/or block diagrams, may be implemented by computerprogram instructions. Such instructions may be provided to a processorof a general purpose computer, special purpose computer,specially-equipped computer (e.g., comprising a high-performancedatabase server, a graphics subsystem, etc.) or other programmable dataprocessing apparatus to produce a machine, such that the instructions,which execute via the processor(s) of the computer or other programmabledata processing apparatus, create means for implementing the actsspecified in the flow chart and/or block diagram block or blocks. Thesecomputer program instructions may also be stored in a non-transitorycomputer-readable memory that can direct a computer or otherprogrammable data processing apparatus to operate in a particularmanner, such that the instructions stored in the computer-readablememory produce an article of manufacture including instruction meanswhich implement the acts specified in the flow chart and/or blockdiagram block or blocks. The computer program instructions may also beloaded to a computing device or other programmable data processingapparatus to cause operations to be performed on the computing device orother programmable apparatus to produce a computer implemented processsuch that the instructions which execute on the computing device orother programmable apparatus provide steps for implementing the actsspecified in the flow chart and/or block diagram block or blocks.

Any patents and applications and other references noted above, includingany that may be listed in accompanying filing papers, are incorporatedherein by reference. Aspects of the invention can be modified, ifnecessary, to employ the systems, functions, and concepts of the variousreferences described above to provide yet further implementations of theinvention. These and other changes can be made to the invention in lightof the above Detailed Description. While the above description describescertain examples of the invention, and describes the best modecontemplated, no matter how detailed the above appears in text, theinvention can be practiced in many ways. Details of the system may varyconsiderably in its specific implementation, while still beingencompassed by the invention disclosed herein. As noted above,particular terminology used when describing certain features or aspectsof the invention should not be taken to imply that the terminology isbeing redefined herein to be restricted to any specific characteristics,features, or aspects of the invention with which that terminology isassociated. In general, the terms used in the following claims shouldnot be construed to limit the invention to the specific examplesdisclosed in the specification, unless the above Detailed Descriptionsection explicitly defines such terms. Accordingly, the actual scope ofthe invention encompasses not only the disclosed examples, but also allequivalent ways of practicing or implementing the invention under theclaims.

To reduce the number of claims, certain aspects of the invention arepresented below in certain claim forms, but the applicant contemplatesother aspects of the invention in any number of claim forms. Forexample, while only one aspect of the invention is recited as ameans-plus-function claim under 35 U.S.C sec. 112(f) (AIA), otheraspects may likewise be embodied as a means-plus-function claim, or inother forms, such as being embodied in a computer-readable medium. Anyclaims intended to be treated under 35 U.S.C. § 112(f) will begin withthe words “means for,” but use of the term “for” in any other context isnot intended to invoke treatment under 35 U.S.C. § 112(f). Accordingly,the applicant reserves the right to pursue additional claims afterfiling this application, in either this application or in a continuingapplication.

What is claimed is:
 1. A computer-implemented method comprising:receiving, by an information technology (IT) and security operationsapplication executing in a cloud provider network, a request to executea playbook, wherein the playbook defines an ordered set of operations tobe performed in response to identification of incidents in an ITenvironment, and wherein the IT and security operations application isused to monitor a user's network that is external to the cloud providernetwork; determining that the playbook includes custom code, wherein thecustom code is not provided by the IT and security operationsapplication, and wherein the playbook including the custom code isstored at a server located within the user's network; and sending, to aproxy application executing in the user's network, a request to executethe playbook including the custom code, wherein the request causesexecution of the playbook in the user's network.
 2. Thecomputer-implemented method of claim 1, further comprising: receivinginput requesting to save the playbook; detecting the presence of thecustom code in the playbook; establishing a connection with the proxyapplication in the user's network; and sending a representation of theplaybook including the custom code to the proxy application for storagein the user's network.
 3. The computer-implemented method of claim 1,wherein a client device establishes a connection to the proxyapplication using a tunnel bridge, and wherein the tunnel bridgeestablishes a secure connection between the client device and the tunnelbridge and between the tunnel bridge and the proxy application in theuser's network.
 4. The computer-implemented method of claim 1, furthercomprising causing display of the playbook in a web-based playbookeditor, and wherein the web-based playbook editor includes client-sideexecutable logic used to detect the presence of the custom code in theplaybook.
 5. The computer-implemented method of claim 1, wherein theuser's network is associated with a first tenant of the IT and securityoperations application, and wherein the playbook was created by a secondtenant of the IT and security operations application that is differentfrom the first tenant.
 6. The computer-implemented method of claim 1,wherein the playbook includes a node representing a custom code functionblock, an output variable associated with the custom code functionblock, and a connection between the node representing the custom codefunction block and another node of the playbook.
 7. Thecomputer-implemented method of claim 1, wherein the request to executethe playbook is generated automatically responsive to the IT andsecurity operations application identifying an incident in the user'snetwork.
 8. The computer-implemented method of claim 1, wherein the ITand security operations application executes a portion of the playbookusing compute resources provided by the cloud provider network.
 9. Thecomputer-implemented method of claim 1, wherein the playbook is storedin a version-control system repository in the user's network and isexecuted by a playbook execution engine running on compute resources inthe user's network.
 10. The computer-implemented method of claim 1,wherein execution of the playbook in the user's network includesperforming an action that involves interaction with a computing resourcerunning in the cloud provider network.
 11. The computer-implementedmethod of claim 1, wherein the proxy application includes a playbookexecution engine that executes the playbook, and wherein execution ofthe playbook by the playbook execution engine includes obtainingportions of the playbook from a data repository and executing theportions of the playbook on demand.
 12. The computer-implemented methodof claim 1, wherein the request to execute the playbook is a firstrequest to execute a first playbook, and wherein the method furthercomprises: receiving a second request to execute a second playbook,wherein the second playbook does not include custom code; and executingthe second playbook using computing resources of the cloud providernetwork.
 13. The computer-implemented method of claim 1, wherein theproxy application receives a representation of the playbook, wherein therepresentation of the playbook uses a structured data format, andwherein the structured data format identifies one or more code blocksprovided by the IT and security operations application and one or moreportions of custom code.
 14. The computer-implemented method of claim 1,wherein the IT and security operations application obtains data relatedto incidents from a data intake and query system running in the cloudprovider network.
 15. A system comprising: a first one or moreelectronic devices to implement an information technology (IT) andsecurity operations application executing in a cloud provider network,the IT and security operations application including instructions thatupon execution cause the IT and security operations application to:receive a request to execute a playbook, wherein the playbook defines anordered set of operations to be performed in response to identificationof incidents in an IT environment, and wherein the IT and securityoperations application is used to monitor a user's network that isexternal to the cloud provider network, determine that the playbookincludes custom code, wherein the custom code is not provided by the ITand security operations application, and wherein the playbook includingthe custom code is stored at a server located within the user's network,and send, to a proxy application executing in the user's network, arequest to execute the playbook including the custom code; and a secondone or more electronic devices to implement the proxy application in theuser's network, the proxy application including instructions that uponexecution cause the proxy application to: receive the request to executethe playbook including the customer code, and execute the playbookincluding the custom code.
 16. The system of claim 15, wherein the ITand security operations application further includes instructions thatupon execution cause the IT and security operations application to:receive input requesting to save the playbook; detect the presence ofthe custom code in the playbook; establish a connection with the proxyapplication in the user's network; and send a representation of theplaybook including the custom code to the proxy application for storagein the user's network.
 17. The system of claim 15, wherein a clientdevice establishes a connection to the proxy application using a tunnelbridge, and wherein the tunnel bridge establishes a secure connectionbetween the client device and the tunnel bridge and between the tunnelbridge and the proxy application in the user's network.
 18. The systemof claim 15, wherein the IT and security operations application furtherincludes instructions that upon execution cause the IT and securityoperations application to cause display of the playbook in a web-basedplaybook editor, and wherein the web-based playbook editor includesclient-side executable logic used to detect the presence of the customcode in the playbook.
 19. The system of claim 15, wherein the user'snetwork is associated with a first tenant of the IT and securityoperations application, and wherein the playbook was created by a secondtenant of the IT and security operations application that is differentfrom the first tenant.
 20. The system of claim 15, wherein the playbookincludes a node representing a custom code function block, an outputvariable associated with the custom code function block, and aconnection between the node representing the custom code function blockand another node of the playbook.